tuain-ng-forms-lib 14.4.93 → 14.4.95

package/lib/classes/forms/action.d.ts

@@ -0,0 +1,22 @@
+import { Subject } from 'rxjs';
+import { FormElement } from './element';
+export declare class FormAction extends FormElement {
+    private readonly _actionActivated;
+    inProgress: boolean;
+    newState: string;
+    backend: boolean;
+    actionCode: string;
+    actionName: string;
+    iconName: string;
+    restrictedOnField: string;
+    restrictedOnOperator: string;
+    restrictedOnValue: string;
+    customValidation: any;
+    constructor(actionDefinition: any, formConfig: any);
+    get actionActivated(): Subject<string>;
+    start(): void;
+    stop(): void;
+    notifyActivation(): void;
+    updateFromServer(receivedAction: any): void;
+    setCustomValidation(callback: any): void;
+}

package/lib/classes/forms/element.d.ts

@@ -0,0 +1,17 @@
+import { FormPiecePropagate } from './piece-propagate';
+export declare class FormElement extends FormPiecePropagate {
+    elementType: string | null;
+    constructor(elementDefinition: any, formConfig: any);
+    setAttr(attr: any, value: any): void;
+    isField(): boolean;
+    isAction(): boolean;
+    isTable(): boolean;
+    /**
+     * @deprecated Utilizar viewOnState
+     */
+    supportState(state: string): boolean;
+    /**
+     * @deprecated Utilizar viewOnState
+     */
+    supportMode(state: string): boolean;
+}

package/lib/classes/forms/field.d.ts

@@ -0,0 +1,205 @@
+import { Subject } from 'rxjs';
+import { FormElement } from './element';
+export interface DetailEvent {
+    code: string;
+    detail: any;
+}
+export interface FieldOption {
+    fieldOptionValue: string;
+    fieldOptionId: string;
+}
+export declare class FieldDescriptor extends FormElement {
+    private readonly _editionFinish;
+    private readonly _editionPartial;
+    private readonly _detailRequest;
+    private _errorType;
+    private _errorCode;
+    private _errorMessage;
+    private _fieldCode;
+    private _intrinsicErrorMessage;
+    private _minValue;
+    private _maxValue;
+    private _maxLength;
+    private _minLength;
+    private _focus;
+    private _onValidation;
+    private _validateOnServer;
+    private _value;
+    private _visibleLabel;
+    private _captureType;
+    private _defaultValue;
+    private _defaultEditable;
+    private _externalValue;
+    private _fieldAlignment;
+    private _fieldInfo;
+    private _fieldRequired;
+    private _fieldTitle;
+    private _fieldType;
+    private _fieldFormat;
+    private _fieldOptions;
+    private _hasChanged;
+    private _outputOnly;
+    private _tooltipText;
+    constructor(inputFieldReceived: any, formConfig: any);
+    get alignment(): string;
+    set alignment(alignment: string);
+    get backend(): boolean;
+    get captureType(): string;
+    set captureType(captureType: string);
+    get code(): string;
+    get fieldCode(): string;
+    get defaultValue(): string;
+    set defaultValue(defaultValue: string);
+    get defaultEditable(): boolean;
+    set defaultEditable(editable: boolean);
+    get detailRequest(): Subject<DetailEvent>;
+    get editionFinish(): Subject<any>;
+    get editionPartial(): Subject<any>;
+    get empty(): boolean;
+    get error(): {
+        type: string;
+        code: string;
+        message: string;
+    };
+    set error(errorObj: {
+        type: string;
+        code: string;
+        message: string;
+    });
+    get errorCode(): string;
+    set errorCode(code: string);
+    get errorMessage(): string;
+    set errorMessage(msg: string);
+    get errorType(): string;
+    get externalValue(): any;
+    get format(): RegExp;
+    set format(format: RegExp);
+    get hasChanged(): boolean;
+    set hasChanged(hasChanged: boolean);
+    get info(): string;
+    set info(newInfo: string);
+    set intrinsicErrorMessage(message: string);
+    get maxLength(): any;
+    set maxLength(requiredMaxLength: any);
+    get maxValue(): any;
+    set maxValue(inputMaxValue: any);
+    get minLength(): number;
+    set minLength(requiredMinLength: number);
+    get minValue(): any;
+    set minValue(inputMinValue: any);
+    get name(): string;
+    get options(): FieldOption[] | null;
+    set options(newOptions: FieldOption[] | null);
+    get optionText(): string;
+    get outputOnly(): boolean;
+    set outputOnly(outputOnly: boolean);
+    get required(): boolean;
+    set required(required: boolean);
+    get title(): string;
+    set title(title: string);
+    get tooltip(): string;
+    set tooltip(tooltip: string);
+    get type(): string;
+    set type(fieldType: string);
+    get validating(): boolean;
+    set validating(isValidating: boolean);
+    get value(): any;
+    get validateOnServer(): boolean;
+    set validateOnServer(validateOnServer: boolean);
+    get serverAction(): boolean;
+    set serverAction(validateOnServer: boolean);
+    set value(newValue: any);
+    get visibleLabel(): boolean;
+    set visibleLabel(visibleLabel: boolean);
+    /**
+     * @deprecated Use options
+     */
+    get fieldOptions(): FieldOption[];
+    /**
+     * @deprecated Use options
+     */
+    set fieldOptions(options: FieldOption[]);
+    /**
+     * @deprecated Use value
+     */
+    get fieldValue(): any;
+    /**
+     * @deprecated Use hasChanged
+     */
+    changed(hasChanged?: boolean): void;
+    clean(): void;
+    focus(): void;
+    getErrorCode(): string;
+    setErrorCode(code: any): void;
+    getErrorMessage(): string;
+    setErrorMessage(msg: any): void;
+    getRequired(): boolean;
+    hasError(): boolean;
+    hideLabel(): void;
+    resetError(): void;
+    setEditable(editable?: boolean): void;
+    setValue(newValue: any, widgetUpdate?: boolean): void;
+    showLabel(): void;
+    /**
+     * @deprecated Use title
+     */
+    setLabel(label: any): void;
+    /**
+     * @deprecated Use required
+     */
+    setRequired(required: boolean): void;
+    /**
+     * @deprecated Use changed
+     */
+    setChanged(hasChanged: boolean): void;
+    /**
+     * @deprecated Use value
+     */
+    getValue(): any;
+    /**
+     * @deprecated Use empty
+     */
+    isEmpty(): boolean;
+    /**
+     * @deprecated Use error
+     */
+    getError(): {
+        type: string;
+        code: string;
+        message: string;
+    };
+    /**
+     * @deprecated Use optionText
+     */
+    getOptionText(): string;
+    /**
+     * @deprecated Use options
+     */
+    getFieldOptions(): FieldOption[];
+    /**
+     * @deprecated Use options
+     */
+    setFieldOptions(newOptions: any): any;
+    /**
+     * @deprecated Use intrinsicErrorMessage
+     */
+    setIntrinsicErrorMessage(message: string): void;
+    /**
+     * @deprecated Use maxValue
+     */
+    setMaxValue(inputMaxValue: any): void;
+    /**
+     * @deprecated Use minValue
+     */
+    setMinValue(inputMinValue: any): void;
+    /**
+     * @deprecated Use showLabel
+     */
+    setVisibleLabel(visibleLabel: boolean): void;
+    notifyEditionPartial(): void;
+    notifyEditionFinish(): void;
+    notifyEditionDetailRequest(detail: any): void;
+    setError(code: any, message: any, type?: string): void;
+    updateFromServer(fld: any): void;
+    private _setValue;
+}

package/lib/classes/forms/form.constants.d.ts

@@ -0,0 +1,25 @@
+export declare const NO_ERROR = "00";
+export declare const HEADER = "HEADER";
+export declare const elementTypes: {
+    action: string;
+    field: string;
+    table: string;
+};
+export declare const formActions: {
+    tableAction: string;
+    getData: string;
+    getTableData: string;
+    validate: string;
+};
+export declare const operators: {
+    G: string;
+    L: string;
+    GE: string;
+    LE: string;
+    EQ: string;
+    NEQ: string;
+    HAS: string;
+    NOTHAS: string;
+    BETWEEN: string;
+    IN: string;
+};

package/lib/classes/forms/form.d.ts

@@ -0,0 +1,137 @@
+import { Subject } from 'rxjs';
+import { FormAction } from './action';
+import { FieldDescriptor, FieldOption } from './field';
+import { RecordTable } from './table/table';
+import { RecordFormSection } from './section';
+import { RecordFormSubSection } from './subsection';
+import { TableRecordData } from './table/row-data';
+export interface FieldPayload {
+    fieldCode: string;
+    fieldValue: any;
+    editable: boolean;
+    visible: boolean;
+    required: boolean;
+    fieldOptions: string;
+}
+export interface TablePayload {
+    tableCode: string;
+    visible: boolean;
+    currentPage: number;
+    requestedPage: number;
+    recordsPerPage: number;
+    currentFilter: any;
+    sortingColumn: string;
+    sortingDirection: string;
+}
+export declare class FormStructureAndData {
+    private readonly _stateChange;
+    state: string;
+    _name: string;
+    _formConfig: any;
+    private _title;
+    private _stateFlow;
+    private _fieldArray;
+    private _fields;
+    private _actionArray;
+    private _actions;
+    private _tableArray;
+    private _tables;
+    private _sectionArray;
+    private _sections;
+    private _immutableData;
+    private _extraInfo;
+    private _exclusiveSectionsByAttr;
+    constructor(definitionReceived: any, formConfig: any);
+    getTitle(): string;
+    setTitle(title: string): void;
+    get name(): string;
+    set name(name: string);
+    get defaultState(): string;
+    supportState(state: string): boolean;
+    supportMode(state: string): boolean;
+    get states(): any[];
+    getCurrentState(): string;
+    changeState(newState: string): boolean;
+    get stateChange(): Subject<any>;
+    setStateFlow(states?: any, transitions?: any, defaultState?: string): void;
+    getImmutableElement(name: string): any;
+    set immutableData(immutableData: any);
+    get immutableData(): any;
+    getExtraInfo(name: string): any;
+    set extraInfo(extraInfo: any);
+    get extraInfo(): any;
+    get fields(): any;
+    get fieldNames(): string[];
+    getFields(): FieldDescriptor[];
+    getFieldNames(): string[];
+    getField(code: string): FieldDescriptor;
+    enableField(code: string): void;
+    disableField(code: string): void;
+    getFieldValue(code: string): any;
+    getFieldOptionText(code: string): any;
+    getFieldOptions(code: string): FieldOption[] | null;
+    setFieldValue(code: string, value: any): any;
+    setFieldError(code: string, errorCode: string, message: string, type?: string): any;
+    setFieldIntrinsicErrorMessage(code: string, message: string): any;
+    setFieldRequired(inputCodes: string[] | string | null, required: boolean): any;
+    setFieldErrorMessage(code: string, message: string): any;
+    setFieldOptions(code: string, optionsArray: any[], idAttribute: string, nameAttribute: string): any;
+    getFieldSet(filter: any, inputCodes: string[] | string | null, secCode?: string | null, subCode?: string | null): string[];
+    applyOnFields(processFunc: any, inputCodes?: string[] | string | null, secCode?: string, subCode?: string): number;
+    enableFields(codes?: string[] | string | null, secCode?: string, subCode?: string): number;
+    showFields(codes?: string[] | string | null, secCode?: string, subCode?: string): number;
+    hideFields(codes?: string[] | string | null, secCode?: string, subCode?: string): number;
+    showLabelFields(codes?: string[] | string | null, secCode?: string, subCode?: string): number;
+    hideLabelFields(codes?: string[] | string | null, secCode?: string, subCode?: string): number;
+    disableFields(codes?: string[] | string | null, secCode?: string, subCode?: string): number;
+    cleanFields(codes?: string[] | string | null, secCode?: string, subCode?: string): number;
+    tagFieldsWithError(message: string, codes?: string[] | string | null, secCode?: string, subCode?: string): number;
+    cleanErrorFields(codes?: string[] | string | null, secCode?: string, subCode?: string): number;
+    tagEmptyRequiredFields(message: string, codes?: any, secCode?: string, subCode?: string): boolean;
+    getRequiredFields(codes?: string[] | string | null, secCode?: string, subCode?: string): string[];
+    getRequiredEmptyFields(codes?: string[] | string | null, secCode?: string, subCode?: string): string[];
+    getChangedFields(codes?: string[] | string | null, secCode?: string, subCode?: string): string[];
+    getFieldsWithValidationIssues(codes?: string[] | string | null, secCode?: string, subCode?: string): string[];
+    getFieldsValues(inputCodes?: string[] | string | null, secCode?: string, subCode?: string): any;
+    get actions(): {};
+    getActionsByAttribute(name: string, value: any): FormAction[];
+    getActions(): FormAction[];
+    getAction(code: string): FormAction;
+    showActions(codes: string[] | string): void;
+    hideActions(codes: string[] | string): void;
+    enableActions(codes: string[] | string): void;
+    disableActions(codes: string[] | string): void;
+    execOnActions(codes: string[] | string | null, functionName: string): void;
+    get tables(): any;
+    getTables(): RecordTable[];
+    getTable(code: string): RecordTable;
+    getTableRecord(code: string, id: string): TableRecordData;
+    enableTables(codes: string[] | string): void;
+    disableTables(codes: string[] | string): void;
+    showTables(codes: string[] | string): void;
+    hideTables(codes: string[] | string): void;
+    cleanTables(codes: string[] | string): void;
+    execOnTables(codes: string[] | string | null, functionName: string): void;
+    get sections(): any;
+    getSections(): RecordFormSection[];
+    getSectionsByAttribute(name: any, value: any): RecordFormSection[];
+    get sectionTitles(): string[];
+    get visibleSections(): RecordFormSection[];
+    getSection(code: string): RecordFormSection;
+    showSections(codes: string[] | string): void;
+    hideSections(codes: string[] | string): void;
+    activeSection(): string;
+    getSubSection(code: string, subCode: any): RecordFormSubSection;
+    showSubSections(code: string, subCodes: string[] | string): void;
+    hideSubSections(code: string, subCodes: string[] | string): void;
+    getSectionActions(code: any): FormAction[];
+    getSectionActionNames(code: any): string[];
+    activateSection(code: string): void;
+    execOnSections(codes: string[] | string | null, functionName: string): void;
+    execOnSubSections(code: string, subNames: string[] | string | null, functionName: string): void;
+    /**
+     * Métodos propios de gestión del formulario
+     */
+    cleanData(): void;
+    getPayload(): any;
+}

package/lib/classes/forms/piece-propagate.d.ts

@@ -0,0 +1,13 @@
+import { BehaviorSubject } from 'rxjs';
+import { FormPiece } from './piece';
+export declare class FormPiecePropagate extends FormPiece {
+    protected propagationCustomAttributes: string[];
+    protected _attributeChange: BehaviorSubject<any>;
+    constructor(pieceDefinition: any, formConfig: any);
+    get attributeChange(): BehaviorSubject<any>;
+    propagateAttribute(name: any, value: any): void;
+    setCustomAttribute(name: string, value: any): void;
+    setVisibility(visible: boolean, forced?: boolean | null): void;
+    set enabled(enabled: any);
+    formStateChange(state: any): void;
+}

package/lib/classes/forms/piece.d.ts

@@ -0,0 +1,41 @@
+export declare class FormPiece {
+    protected _formState: string;
+    protected _visibleForced: boolean;
+    protected _isForced: boolean;
+    protected _absoluteVisible: boolean;
+    protected _absoluteDisabled: boolean;
+    protected visibleStates: string[] | null;
+    protected enabledStates: string[] | null;
+    _formConfig: any;
+    _visible: boolean;
+    _disabled: boolean;
+    customAttributes: any;
+    constructor(pieceDefinition: any, formConfig: any);
+    getCustomAttribute(name: string): any;
+    setCustomAttribute(name: string, value: any): void;
+    setCustomAttributes(attributes: any): void;
+    matchAttribute(name: string, value: string): boolean;
+    setVisibleStates(newStates: any): void;
+    setEnabledStates(newStates: any): void;
+    viewOnState(state: string): boolean;
+    enabledOnState(state: string): boolean;
+    get absoluteVisible(): boolean;
+    get absoluteDisabled(): boolean;
+    get visible(): boolean;
+    set visible(visible: boolean);
+    visibleOn(state: string): boolean;
+    enabledOn(state: string): boolean;
+    setVisibility(visible: boolean, forced?: boolean | null): void;
+    show(forced?: boolean | null): void;
+    hide(forced?: boolean | null): void;
+    get enabled(): boolean;
+    set enabled(enabled: boolean);
+    get editable(): boolean;
+    get disabled(): boolean;
+    set disabled(disabled: boolean);
+    enable(): void;
+    disable(): void;
+    formStateChangeCustomSubscribe(formChangeSubject: any): void;
+    formStateChange(state: any): void;
+    subscribeFormStateChange(formChangeSubject: any): void;
+}

package/lib/classes/forms/section.d.ts

@@ -0,0 +1,32 @@
+import { Subject } from 'rxjs';
+import { FormPiecePropagate } from './piece-propagate';
+import { FormAction } from './action';
+import { RecordFormSubSection } from './subsection';
+export declare class RecordFormSection extends FormPiecePropagate {
+    private readonly _activation;
+    private readonly _inactivation;
+    active: boolean;
+    sectionId: string | null;
+    sectionCode: string | null;
+    sectionTitle: string | null;
+    subSections: RecordFormSubSection[];
+    subSectionsObj: any;
+    private _exclusiveSubSectionsByAttr;
+    constructor(sectionReceived: any, formObject: any, formConfig: any);
+    get code(): string;
+    get activation(): Subject<string>;
+    get inactivation(): Subject<string>;
+    activate(): void;
+    inactivate(): void;
+    get title(): string;
+    set title(title: string);
+    getVisibleSubsections(state: any): RecordFormSubSection[];
+    getSubsection(subSectionCode: any): any;
+    activateSubSection(subSectionCode: any): void;
+    getFields(): any[];
+    getActions(): FormAction[];
+    getActionNames(): string[];
+    getFieldNames(): string[];
+    getField(name: any): any;
+    formStateChangeCustomSubscribe(formChangeSubject: any): void;
+}

package/lib/classes/forms/subsection.d.ts

@@ -0,0 +1,24 @@
+import { FormPiecePropagate } from './piece-propagate';
+import { FormAction } from './action';
+export declare class RecordFormSubSection extends FormPiecePropagate {
+    _customRender: string | null;
+    subsectionId: string | null;
+    subsectionCode: string | null;
+    subsectionTitle: string | null;
+    subSectionElements: any[];
+    subSectionFields: any[];
+    subSectionTables: any[];
+    subSectionActions: any[];
+    elementsArray: any;
+    active: boolean;
+    constructor(subsectionReceived: any, formObject: any, formConfig: any);
+    get customRender(): string;
+    set customRender(customRenderName: string);
+    getField(name: any): any;
+    getFields(): any[];
+    getFieldNames(): any[];
+    getActions(): FormAction[];
+    getActionNames(): string[];
+    activate(): void;
+    inactivate(): void;
+}

package/lib/classes/forms/table/action.d.ts

@@ -0,0 +1,15 @@
+import { FormPiece } from '../piece';
+export declare class TableAction extends FormPiece {
+    newState: string;
+    actionCode: string;
+    actionTitle: string;
+    iconName: string;
+    actionType: string;
+    actionClass: string;
+    stateField: string;
+    backend: boolean;
+    restrictedOnField: string;
+    restrictedOnValue: string;
+    restrictedOnOperator: string;
+    constructor(actionDefinition: any, formConfig: any);
+}

package/lib/classes/forms/table/column.d.ts

@@ -0,0 +1,33 @@
+import { FormPiece } from '../piece';
+export interface FilterDef {
+    operators: string[];
+    options: any[];
+}
+export interface FilterSetup {
+    fieldCode: string;
+    operator: string;
+    values: any[];
+}
+export declare class RecordTableColumn extends FormPiece {
+    fieldCode: string;
+    fieldTitle: string;
+    fieldType: string;
+    fieldAlignment: string;
+    fieldFormat: string;
+    sortable: boolean;
+    searchable: boolean;
+    sortDirections: string[];
+    filterVisible: boolean;
+    filterDef: FilterDef | null;
+    filterSetup: FilterSetup | null;
+    constructor(recTableColReceived: any, formConfig: any);
+    setSearchable(searchable?: boolean): void;
+    hideFilter(): void;
+    addFilterDefinition(filterDefinition: any): void;
+    get filterDefinition(): FilterDef;
+    addFilter(columnValues: any, operator: any): void;
+    get filter(): FilterSetup;
+    removeFilter(): void;
+    get options(): any[];
+    serSortDirections(ascend: boolean, descend: boolean): void;
+}

package/lib/classes/forms/table/row-data.d.ts

@@ -0,0 +1,14 @@
+import { RecordTableColumn } from './column';
+export declare class TableRecordData {
+    recordId: string | null;
+    selected: boolean;
+    recordData: any;
+    constructor(recordReceived: any, recordDefinition: RecordTableColumn[], selectionFieldName?: any);
+    toggleSelect(): void;
+    select(): void;
+    unselect(): void;
+    get recordIdKey(): string;
+    getFieldValue(fieldCode: any): any;
+    hasPattern(words: any, columnObj: any): boolean;
+    hasCondition(columnFilters: any): boolean;
+}

package/lib/classes/forms/table/table.d.ts

@@ -0,0 +1,100 @@
+import { Subject } from 'rxjs';
+import { FormElement } from '../element';
+import { RecordTableColumn } from './column';
+import { TableAction } from './action';
+import { TableRecordData } from './row-data';
+export interface TableActionEvent {
+    actionCode: string;
+    recordId: any;
+    recordData: any;
+}
+export interface TableEvent {
+    tableCode: string;
+    actionCode: string | null;
+    actionDetail: any;
+}
+export declare class RecordTable extends FormElement {
+    private readonly _inlineActionTrigger;
+    private readonly _globalActionTrigger;
+    private readonly _recordSelectionTrigger;
+    private readonly _selectionActionTrigger;
+    private readonly _getDataTrigger;
+    private _tableColumnObj;
+    private _appendPages;
+    private _actions;
+    private _actionsObj;
+    private globalFilterString;
+    private globalFilterStrings;
+    private selectedRecords;
+    private restrictedId;
+    private layout;
+    globalSearch: boolean;
+    tableRecords: TableRecordData[];
+    tableRecordObj: {};
+    visibleRecords: TableRecordData[] | null;
+    columns: RecordTableColumn[];
+    selectable: boolean;
+    selectionBackend: boolean;
+    selectionField: string;
+    allSelected: boolean;
+    tableCode: string;
+    tableTitle: string;
+    currentPage: number;
+    totalPages: number;
+    requestedPage: number;
+    recordsPerPage: number;
+    totalRecordsNumber: number;
+    recordsNumber: number;
+    sorting: any;
+    waiting: boolean;
+    clientPaging: boolean;
+    sortable: boolean;
+    constructor(tableReceived: any, formConfig: any);
+    get columnNames(): string[];
+    get inlineActionTrigger(): Subject<TableEvent>;
+    get globalActionTrigger(): Subject<TableEvent>;
+    get selectionActionTrigger(): Subject<TableEvent>;
+    get recordSelectionTrigger(): Subject<TableEvent>;
+    get getDataTrigger(): Subject<TableEvent>;
+    getLayout(): string;
+    setLayout(layout: any): void;
+    hasActions(): boolean;
+    getSelectedRecords(): string[];
+    activateGlobalSearch(): void;
+    inactivateGlobalSearch(): void;
+    columnDefinition(fieldCode: any): RecordTableColumn;
+    putOnWait(): void;
+    freeWaiting(): void;
+    notifyGlobalAction(actionCode: any): void;
+    notifyInlineAction(tableActionEvent: TableActionEvent): void;
+    notifyRecordSelection(recordId: any): void;
+    notifySelectionAction(actionCode: any): void;
+    notifyGetDataAction(requestedPage?: any): any;
+    clean(): void;
+    selectAll(): boolean;
+    unSelectAll(): boolean;
+    setTableRecords(tableRecords: any, append: any): void;
+    appendRecords(records: any): void;
+    replaceRecords(records: any): void;
+    setTableAppend(append: boolean): void;
+    changePage(requestedPage: any): void;
+    updateVisibleRecords(): void;
+    updateFromServer(tableReceived: any): void;
+    getTableRecord(recordId: any): any;
+    getAction(actionCode: any): any;
+    getActions(actionClass?: string, actionTypes?: string[]): TableAction[];
+    setFilterById(id: any): void;
+    cleanIdFilter(): void;
+    setGlobalFilterString(text: any, notifyComponent?: boolean): void;
+    addFilterDefinition(columnName: any, filterDefinition: any): void;
+    getFilteredRecords(): TableRecordData[];
+    getColumnFilter(columnName: string): import("./column").FilterSetup;
+    addColumnFilter(columnName: string, columnValues: any | any[], operator?: string): void;
+    removeColumnFilter(columnName: string): void;
+    get currentFilter(): any;
+    sort(columnName: any, direction: any): void;
+    setRequiredOrder(columnField: any, direction?: any): void;
+    localSortData(): void;
+    recordCompare(recordA: TableRecordData, recordB: TableRecordData, columnCompare: any, direction: any): number;
+    formStateChangeCustomSubscribe(formChangeSubject: any): void;
+}