tuain-ng-forms-lib 14.0.2 → 14.0.4

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,41 @@
+export declare class FormElement {
+    protected _visible: boolean;
+    protected _visibleForced: boolean;
+    protected _isForced: boolean;
+    _formConfig: any;
+    disabled: boolean;
+    visibleStates: string[];
+    enabledStates: string[];
+    elementType: string;
+    customAttributes: any;
+    constructor(elementDefinition: any, formConfig: any);
+    getCustomAttribute(name: string): any;
+    setCustomAttribute(name: string, value: any): void;
+    matchAttribute(name: string, value: string): boolean;
+    isField(): boolean;
+    isAction(): boolean;
+    isTable(): boolean;
+    setVisibleStates(newStates: any): void;
+    setEnabledStates(newStates: any): void;
+    viewOnState(state: string): boolean;
+    enabledOnState(state: string): boolean;
+    /**
+     * @deprecated Utilizar viewOnState
+     */
+    supportState(state: string): boolean;
+    /**
+     * @deprecated Utilizar viewOnState
+     */
+    supportMode(state: string): boolean;
+    get visible(): boolean;
+    set visible(visible: boolean);
+    visibleOn(state: string): boolean;
+    enabledOn(state: string): boolean;
+    setVisibility(visible: boolean, forced?: boolean): void;
+    show(forced?: boolean): void;
+    hide(forced?: boolean): void;
+    enable(): void;
+    disable(): void;
+    get enabled(): boolean;
+    get editable(): boolean;
+}

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

@@ -0,0 +1,109 @@
+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 readonly _attributeChange;
+    private validateOnServer;
+    private _value;
+    private _focus;
+    private _minValue;
+    private _maxValue;
+    private _maxLength;
+    _onValidation: boolean;
+    _intrinsicErrorMessage: string;
+    fieldCode: string;
+    fieldInfo: string;
+    defaultValue: string;
+    defaultEditable: boolean;
+    visibleLabel: boolean;
+    fieldRequired: boolean;
+    hasChanged: boolean;
+    outputOnly: boolean;
+    captureType: string;
+    fieldTitle: string;
+    fieldType: string;
+    fieldAlignment: string;
+    fieldFormat: RegExp;
+    externalValue: any;
+    tooltipText: string;
+    errorType: string;
+    errorCode: string;
+    errorMessage: string;
+    fieldOptions: FieldOption[];
+    constructor(inputFieldReceived: any, formConfig: any);
+    get name(): string;
+    get editionFinish(): Subject<any>;
+    get attributeChange(): Subject<any>;
+    get editionPartial(): Subject<any>;
+    get detailRequest(): Subject<DetailEvent>;
+    get info(): string;
+    get validating(): boolean;
+    set validating(isValidating: boolean);
+    focus(): void;
+    setIntrinsicErrorMessage(message: string): void;
+    set intrinsicErrorMessage(message: string);
+    get fieldValue(): any;
+    getRequired(): boolean;
+    setRequired(required: boolean): void;
+    get required(): boolean;
+    set required(required: boolean);
+    get maxLength(): any;
+    set maxLength(requiredMaxLength: any);
+    get value(): any;
+    set value(newValue: any);
+    notifyEditionPartial(): void;
+    notifyEditionFinish(): void;
+    setAttr(name: string, value: any): void;
+    notifyEditionDetailRequest(detail: any): void;
+    setVisibleLabel(visibleLabel: boolean): void;
+    showLabel(): void;
+    hideLabel(): void;
+    setChanged(hasChanged: boolean): void;
+    changed(): void;
+    setLabel(label: any): void;
+    clean(): void;
+    get backend(): boolean;
+    setEditable(editable?: boolean): void;
+    hasError(): boolean;
+    resetError(): void;
+    setError(code: any, message: any, type?: string): void;
+    getError(): {
+        type: string;
+        code: string;
+        message: string;
+    };
+    get error(): {
+        type: string;
+        code: string;
+        message: string;
+    };
+    set error(errorObj: {
+        type: string;
+        code: string;
+        message: string;
+    });
+    getErrorCode(): string;
+    setErrorCode(code: any): void;
+    getErrorMessage(): string;
+    setErrorMessage(msg: any): void;
+    get empty(): boolean;
+    isEmpty(): boolean;
+    getValue(): any;
+    getOptionText(): string;
+    updateFromServer(fld: any): void;
+    setMinValue(inputMinValue: any): void;
+    setMaxValue(inputMaxValue: any): void;
+    getFieldOptions(): FieldOption[];
+    setFieldOptions(newOptions: any): void;
+    setValue(newValue: any, widgetUpdate?: boolean): boolean;
+}

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,134 @@
+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 {
+    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;
+    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[];
+    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/section.d.ts

@@ -0,0 +1,39 @@
+import { Subject } from 'rxjs';
+import { FormAction } from './action';
+import { RecordFormSubSection } from './subsection';
+export declare class RecordFormSection {
+    private readonly _activation;
+    private readonly _inactivation;
+    visible: boolean;
+    visibleStates: string[];
+    active: boolean;
+    sectionId: string;
+    sectionCode: string;
+    sectionTitle: string;
+    customAttributes: any;
+    subSections: RecordFormSubSection[];
+    subSectionsObj: any;
+    constructor(sectionReceived: any, formObject: any);
+    getCustomAttribute(name: any): any;
+    setCustomAttribute(name: any, value: any): any;
+    matchAttribute(name: any, value: any): boolean;
+    get code(): string;
+    get activation(): Subject<string>;
+    get inactivation(): Subject<string>;
+    activate(): void;
+    inactivate(): void;
+    show(): void;
+    hide(): void;
+    get title(): string;
+    set title(title: string);
+    getVisibleSubsections(state: any): RecordFormSubSection[];
+    getSubsection(subSectionCode: any): any;
+    getFields(): any[];
+    getActions(): FormAction[];
+    getActionNames(): string[];
+    getFieldNames(): any[];
+    getField(name: any): any;
+    supportState(state: any): boolean;
+    viewOnState(state: any): boolean;
+    supportMode(state: any): boolean;
+}

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

@@ -0,0 +1,26 @@
+import { FormAction } from './action';
+export declare class RecordFormSubSection {
+    visible: boolean;
+    _customRender: string;
+    subsectionId: string;
+    subsectionCode: string;
+    subsectionTitle: string;
+    visibleStates: string[];
+    subSectionElements: any[];
+    subSectionFields: any[];
+    subSectionTables: any[];
+    subSectionActions: any[];
+    elementsArray: any;
+    constructor(subsectionReceived: any, formObject: any);
+    show(): void;
+    hide(): void;
+    get customRender(): string;
+    set customRender(customRenderName: string);
+    getField(name: any): any;
+    getFields(): any[];
+    getFieldNames(): any[];
+    getActions(): FormAction[];
+    getActionNames(): string[];
+    viewOnState(state: any): boolean;
+    supportMode(state: any): boolean;
+}

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

@@ -0,0 +1,20 @@
+export declare class TableAction {
+    visibleStates: string[];
+    enabledStates: string[];
+    newState: string;
+    actionCode: string;
+    actionTitle: string;
+    iconName: string;
+    actionType: string;
+    actionClass: string;
+    stateField: string;
+    backend: boolean;
+    restrictedOnField: string;
+    restrictedOnValue: string;
+    restrictedOnOperator: string;
+    customAttributes: any;
+    constructor(actionDefinition: any);
+    supportMode(state: any): boolean;
+    viewOnState(state: any): boolean;
+    enabledOnState(state: any): boolean;
+}

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

@@ -0,0 +1,33 @@
+export interface FilterDef {
+    operators: string[];
+    options: any[];
+}
+export interface FilterSetup {
+    fieldCode: string;
+    operator: string;
+    values: any[];
+}
+export declare class RecordTableColumn {
+    _formConfig: any;
+    fieldCode: string;
+    fieldTitle: string;
+    fieldType: string;
+    fieldAlignment: string;
+    fieldFormat: string;
+    visible: boolean;
+    sortable: boolean;
+    sortDirections: string[];
+    customAttributes: any;
+    filterVisible: boolean;
+    filterDef: FilterDef;
+    filterSetup: FilterSetup;
+    constructor(recTableColReceived: any, formConfig: any);
+    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;
+    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;
+    actionDetail: any;
+}
+export declare class RecordTable extends FormElement {
+    private readonly _inlineActionTrigger;
+    private readonly _globalActionTrigger;
+    private readonly _recordSelectionTrigger;
+    private readonly _selectionActionTrigger;
+    private readonly _getDataTrigger;
+    private readonly _attributeChange;
+    private _tableColumnObj;
+    private _appendPages;
+    private _actions;
+    private _actionsObj;
+    private globalFilterStrings;
+    private selectedRecords;
+    private globalSearch;
+    private restrictedId;
+    private layout;
+    tableRecords: TableRecordData[];
+    tableRecordObj: {};
+    visibleRecords: TableRecordData[];
+    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>;
+    get attributeChange(): Subject<any>;
+    getLayout(): string;
+    setLayout(layout: any): void;
+    hasActions(): boolean;
+    getSelectedRecords(): string[];
+    activateGlobalSearch(): void;
+    inactivateGlobalSearch(): void;
+    columnDefinition(fieldCode: any): any;
+    putOnWait(): void;
+    freeWaiting(): void;
+    setAttr(name: string, value: any): 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;
+    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): void;
+    addFilterDefinition(columnName: any, filterDefinition: any): void;
+    getFilteredRecords(): TableRecordData[];
+    getColumnFilter(columnName: string): any;
+    addColumnFilter(columnName: string, columnValues: any | any[], operator?: string): any;
+    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;
+}

package/lib/components/elements/action.component.d.ts

@@ -0,0 +1,21 @@
+import { OnInit } from '@angular/core';
+import { FormAction } from '../../classes/forms/action';
+import * as i0 from "@angular/core";
+export declare class ActionComponent implements OnInit {
+    formConfig: any;
+    inProgress: boolean;
+    action: FormAction;
+    busy: any;
+    relatedField: any;
+    state: any;
+    style: string;
+    showLabel: boolean;
+    ngOnInit(): void;
+    start(): void;
+    activate(): void;
+    visibleOnRestriction(): boolean;
+    get visible(): boolean;
+    get disabled(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionComponent, "lib-action", never, { "action": "action"; "busy": "busy"; "relatedField": "relatedField"; "state": "state"; "style": "style"; "showLabel": "showLabel"; }, {}, never, ["*"], false>;
+}

package/lib/components/elements/field.component.d.ts

@@ -0,0 +1,43 @@
+import { OnInit } from '@angular/core';
+import { FieldDescriptor } from '../../classes/forms/field';
+import * as i0 from "@angular/core";
+export declare class FieldComponent implements OnInit {
+    formConfig: any;
+    code: string;
+    value: any;
+    fieldInfo: string;
+    fieldAlignment: string;
+    tooltipText: string;
+    maxLength: any;
+    minValue: any;
+    maxValue: any;
+    onValidation: any;
+    captureType: any;
+    title: any;
+    type: any;
+    visibleLabel: any;
+    required: any;
+    options: any;
+    errorType: any;
+    errorCode: any;
+    errorMessage: any;
+    field: FieldDescriptor;
+    state: any;
+    ngOnInit(): void;
+    dafaultProcessFieldChange(attribute: string, value?: any): void;
+    processFieldChange(attribute: string, value?: any): void;
+    start(): void;
+    focus(): void;
+    updateObject(): void;
+    inputChanged(): void;
+    inputTyped(): void;
+    updateValue(): void;
+    onInputChange(): void;
+    onChangeContent(): void;
+    onShowInfo(detail?: any): void;
+    numberInputValidation(event: any): boolean;
+    get visible(): boolean;
+    get disabled(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FieldComponent, "lib-field", never, { "field": "field"; "state": "state"; }, {}, never, ["*"], false>;
+}

package/lib/components/elements/layout/element.component.d.ts

@@ -0,0 +1,14 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ElementComponent implements OnInit {
+    formConfig: any;
+    element: any;
+    form: any;
+    state: any;
+    ngOnInit(): void;
+    start(): void;
+    get visible(): any;
+    get disabled(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ElementComponent, "lib-element", never, { "element": "element"; "form": "form"; "state": "state"; }, {}, never, ["*"], false>;
+}

package/lib/components/elements/layout/form-error.component.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class FormErrorComponent {
+    errorTitle: any;
+    errorMessage: any;
+    errorType: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormErrorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormErrorComponent, "lib-form-error", never, { "errorTitle": "errorTitle"; "errorMessage": "errorMessage"; "errorType": "errorType"; }, {}, never, ["*"], false>;
+}

package/lib/components/elements/layout/form-header.component.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FormHeaderComponent {
+    formManager: any;
+    goBackAction: boolean;
+    showTitle: any;
+    headerActions: any;
+    goBackEvent: EventEmitter<object>;
+    goBackForm(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormHeaderComponent, "lib-form-header", never, { "formManager": "formManager"; "goBackAction": "goBackAction"; "showTitle": "showTitle"; "headerActions": "headerActions"; }, { "goBackEvent": "goBackEvent"; }, never, ["*"], false>;
+}