@ngx-smz/core 19.2.0

package/lib/builders/smz-documents/content-cells/field.d.ts

@@ -0,0 +1,26 @@
+import { SmzDocumentCell } from '../../../modules/smz-documents/models/smz-document';
+import { SmzDocumentField } from '../../../modules/smz-documents/models/smz-document-features';
+import { SmzDocumentBaseCellBuilder } from '../document-base-cell';
+import { SmzDocumentBuilder } from '../document-builder';
+import { SmzDocumentRowBuilder } from '../document-content';
+export declare class SmzCellFieldBuilder extends SmzDocumentBaseCellBuilder<SmzCellFieldBuilder> {
+    _rowBuilder: SmzDocumentRowBuilder;
+    _cell: SmzDocumentCell;
+    _data: SmzDocumentField;
+    _documentBuilder: SmzDocumentBuilder;
+    protected that: this;
+    constructor(_rowBuilder: SmzDocumentRowBuilder, _cell: SmzDocumentCell, _data: SmzDocumentField, _documentBuilder: SmzDocumentBuilder);
+    overrideContainerStyles(styleClass: string): SmzCellFieldBuilder;
+    overrideLabelStyles(styleClass: string): SmzCellFieldBuilder;
+    overrideTextStyles(styleClass: string): SmzCellFieldBuilder;
+    addContainerStyles(styleClass: string): SmzCellFieldBuilder;
+    useBorder(): SmzCellFieldBuilder;
+    addLabelStyles(styleClass: string): SmzCellFieldBuilder;
+    addTextStyles(styleClass: string): SmzCellFieldBuilder;
+    setBackgroundColor(color: string): SmzCellFieldBuilder;
+    setLabelColor(color: string): SmzCellFieldBuilder;
+    setTextColor(color: string): SmzCellFieldBuilder;
+    useCentralized(): SmzCellFieldBuilder;
+    useBold(): SmzCellFieldBuilder;
+    useAlert(): SmzCellFieldBuilder;
+}

package/lib/builders/smz-documents/content-cells/fields-group.d.ts

@@ -0,0 +1,39 @@
+import { SmzDocumentCell } from '../../../modules/smz-documents/models/smz-document';
+import { SmzDocumentFieldsGroup } from '../../../modules/smz-documents/models/smz-document-features';
+import { SmzDocumentBaseCellBuilder, SmzDocumentWidthTypes } from '../document-base-cell';
+import { SmzDocumentBuilder } from '../document-builder';
+import { SmzDocumentRowBuilder } from '../document-content';
+export declare class SmzCellFieldsGroupBuilder extends SmzDocumentBaseCellBuilder<SmzCellFieldsGroupBuilder> {
+    _rowBuilder: SmzDocumentRowBuilder;
+    _cell: SmzDocumentCell;
+    _data: SmzDocumentFieldsGroup;
+    _documentBuilder: SmzDocumentBuilder;
+    protected that: this;
+    constructor(_rowBuilder: SmzDocumentRowBuilder, _cell: SmzDocumentCell, _data: SmzDocumentFieldsGroup, _documentBuilder: SmzDocumentBuilder);
+    overrideContainerStyles(styleClass: string): SmzCellFieldsGroupBuilder;
+    addContainerStyles(styleClass: string): SmzCellFieldsGroupBuilder;
+    useBorder(): SmzCellFieldsGroupBuilder;
+    setBackgroundColor(color: string): SmzCellFieldsGroupBuilder;
+    addField(text: string, label?: string): SmzCellFieldGroupBuilder;
+}
+export declare class SmzCellFieldGroupBuilder {
+    _groupBuilder: SmzCellFieldsGroupBuilder;
+    _documentBuilder: SmzDocumentBuilder;
+    private _data;
+    constructor(_groupBuilder: SmzCellFieldsGroupBuilder, text: string, label: string, _documentBuilder: SmzDocumentBuilder);
+    setWidth(width: SmzDocumentWidthTypes): SmzCellFieldGroupBuilder;
+    overrideContainerStyles(styleClass: string): SmzCellFieldGroupBuilder;
+    overrideLabelStyles(styleClass: string): SmzCellFieldGroupBuilder;
+    overrideTextStyles(styleClass: string): SmzCellFieldGroupBuilder;
+    addContainerStyles(styleClass: string): SmzCellFieldGroupBuilder;
+    useBorder(): SmzCellFieldGroupBuilder;
+    addLabelStyles(styleClass: string): SmzCellFieldGroupBuilder;
+    addTextStyles(styleClass: string): SmzCellFieldGroupBuilder;
+    setBackgroundColor(color: string): SmzCellFieldGroupBuilder;
+    setLabelColor(color: string): SmzCellFieldGroupBuilder;
+    setTextColor(color: string): SmzCellFieldGroupBuilder;
+    useCentralized(): SmzCellFieldGroupBuilder;
+    useBold(): SmzCellFieldGroupBuilder;
+    useAlert(): SmzCellFieldGroupBuilder;
+    get group(): SmzCellFieldsGroupBuilder;
+}

package/lib/builders/smz-documents/content-cells/hidden-break.d.ts

@@ -0,0 +1,16 @@
+import { SmzDocumentCell } from '../../../modules/smz-documents/models/smz-document';
+import { SmzDocumentHiddenBreak } from '../../../modules/smz-documents/models/smz-document-features';
+import { SmzDocumentBaseCellBuilder } from '../document-base-cell';
+import { SmzDocumentBuilder } from '../document-builder';
+import { SmzDocumentRowBuilder } from '../document-content';
+export declare class SmzCellHiddenBreakBuilder extends SmzDocumentBaseCellBuilder<SmzCellHiddenBreakBuilder> {
+    _rowBuilder: SmzDocumentRowBuilder;
+    _cell: SmzDocumentCell;
+    _data: SmzDocumentHiddenBreak;
+    _documentBuilder: SmzDocumentBuilder;
+    protected that: this;
+    constructor(_rowBuilder: SmzDocumentRowBuilder, _cell: SmzDocumentCell, _data: SmzDocumentHiddenBreak, _documentBuilder: SmzDocumentBuilder);
+    overrideStyles(styleClass: string): SmzCellHiddenBreakBuilder;
+    overrideOverlapStyles(styleClass: string): SmzCellHiddenBreakBuilder;
+    setHiddenBreakHeight(height: string): SmzCellHiddenBreakBuilder;
+}

package/lib/builders/smz-documents/content-cells/image.d.ts

@@ -0,0 +1,20 @@
+import { SmzDocumentCell } from '../../../modules/smz-documents/models/smz-document';
+import { SmzDocumentImage } from '../../../modules/smz-documents/models/smz-document-features';
+import { SmzDocumentBaseCellBuilder } from '../document-base-cell';
+import { SmzDocumentBuilder } from '../document-builder';
+import { SmzDocumentRowBuilder } from '../document-content';
+export declare class SmzCellImageBuilder extends SmzDocumentBaseCellBuilder<SmzCellImageBuilder> {
+    _rowBuilder: SmzDocumentRowBuilder;
+    _cell: SmzDocumentCell;
+    _data: SmzDocumentImage;
+    _documentBuilder: SmzDocumentBuilder;
+    protected that: this;
+    constructor(_rowBuilder: SmzDocumentRowBuilder, _cell: SmzDocumentCell, _data: SmzDocumentImage, _documentBuilder: SmzDocumentBuilder);
+    overrideContainerStyles(styleClass: string): SmzCellImageBuilder;
+    overrideImageStyles(styleClass: string): SmzCellImageBuilder;
+    addContainerStyles(styleClass: string): SmzCellImageBuilder;
+    useBorder(): SmzCellImageBuilder;
+    addImageStyles(styleClass: string): SmzCellImageBuilder;
+    setBackgroundColor(color: string): SmzCellImageBuilder;
+    setImageWidth(width: string): SmzCellImageBuilder;
+}

package/lib/builders/smz-documents/content-cells/page-break.d.ts

@@ -0,0 +1,13 @@
+import { SmzDocumentCell } from '../../../modules/smz-documents/models/smz-document';
+import { SmzDocumentPageBreak } from '../../../modules/smz-documents/models/smz-document-features';
+import { SmzDocumentBaseCellBuilder } from '../document-base-cell';
+import { SmzDocumentBuilder } from '../document-builder';
+import { SmzDocumentRowBuilder } from '../document-content';
+export declare class SmzCellPageBreakBuilder extends SmzDocumentBaseCellBuilder<SmzCellPageBreakBuilder> {
+    _rowBuilder: SmzDocumentRowBuilder;
+    _cell: SmzDocumentCell;
+    _data: SmzDocumentPageBreak;
+    _documentBuilder: SmzDocumentBuilder;
+    protected that: this;
+    constructor(_rowBuilder: SmzDocumentRowBuilder, _cell: SmzDocumentCell, _data: SmzDocumentPageBreak, _documentBuilder: SmzDocumentBuilder);
+}

package/lib/builders/smz-documents/content-cells/spacer.d.ts

@@ -0,0 +1,15 @@
+import { SmzDocumentCell } from '../../../modules/smz-documents/models/smz-document';
+import { SmzDocumentSpacer } from '../../../modules/smz-documents/models/smz-document-features';
+import { SmzDocumentBaseCellBuilder } from '../document-base-cell';
+import { SmzDocumentBuilder } from '../document-builder';
+import { SmzDocumentRowBuilder } from '../document-content';
+export declare class SmzCellSpacerBuilder extends SmzDocumentBaseCellBuilder<SmzCellSpacerBuilder> {
+    _rowBuilder: SmzDocumentRowBuilder;
+    _cell: SmzDocumentCell;
+    _data: SmzDocumentSpacer;
+    _documentBuilder: SmzDocumentBuilder;
+    protected that: this;
+    constructor(_rowBuilder: SmzDocumentRowBuilder, _cell: SmzDocumentCell, _data: SmzDocumentSpacer, _documentBuilder: SmzDocumentBuilder);
+    overrideStyles(styleClass: string): SmzCellSpacerBuilder;
+    setSpacerHeight(height: string): SmzCellSpacerBuilder;
+}

package/lib/builders/smz-documents/content-cells/sub-title.d.ts

@@ -0,0 +1,20 @@
+import { SmzDocumentCell } from '../../../modules/smz-documents/models/smz-document';
+import { SmzDocumentSubTitle } from '../../../modules/smz-documents/models/smz-document-features';
+import { SmzDocumentBaseCellBuilder } from '../document-base-cell';
+import { SmzDocumentBuilder } from '../document-builder';
+import { SmzDocumentRowBuilder } from '../document-content';
+export declare class SmzCellSubTitleBuilder extends SmzDocumentBaseCellBuilder<SmzCellSubTitleBuilder> {
+    _rowBuilder: SmzDocumentRowBuilder;
+    _cell: SmzDocumentCell;
+    _data: SmzDocumentSubTitle;
+    _documentBuilder: SmzDocumentBuilder;
+    protected that: this;
+    constructor(_rowBuilder: SmzDocumentRowBuilder, _cell: SmzDocumentCell, _data: SmzDocumentSubTitle, _documentBuilder: SmzDocumentBuilder);
+    overrideContainerStyles(styleClass: string): SmzCellSubTitleBuilder;
+    overrideTextStyles(styleClass: string): SmzCellSubTitleBuilder;
+    addContainerStyles(styleClass: string): SmzCellSubTitleBuilder;
+    useBorder(): SmzCellSubTitleBuilder;
+    addTextStyles(styleClass: string): SmzCellSubTitleBuilder;
+    setBackgroundColor(color: string): SmzCellSubTitleBuilder;
+    setTextColor(color: string): SmzCellSubTitleBuilder;
+}

package/lib/builders/smz-documents/content-cells/table.d.ts

@@ -0,0 +1,37 @@
+import { Observable } from 'rxjs';
+import { SmzDocumentCell } from '../../../modules/smz-documents/models/smz-document';
+import { SmzDocumentTable } from '../../../modules/smz-documents/models/smz-document-features';
+import { SmzDocumentBaseCellBuilder, SmzDocumentWidthTypes } from '../document-base-cell';
+import { SmzDocumentBuilder } from '../document-builder';
+import { SmzDocumentRowBuilder } from '../document-content';
+export declare class SmzCellTableBuilder extends SmzDocumentBaseCellBuilder<SmzCellTableBuilder> {
+    _rowBuilder: SmzDocumentRowBuilder;
+    _cell: SmzDocumentCell;
+    _data: SmzDocumentTable;
+    _documentBuilder: SmzDocumentBuilder;
+    protected that: this;
+    constructor(_rowBuilder: SmzDocumentRowBuilder, _cell: SmzDocumentCell, _data: SmzDocumentTable, _documentBuilder: SmzDocumentBuilder);
+    overrideContainerStyles(styleClass: string): SmzCellTableBuilder;
+    addContainerStyles(styleClass: string): SmzCellTableBuilder;
+    useBorder(): SmzCellTableBuilder;
+    setContainerBackgroundColor(color: string): SmzCellTableBuilder;
+    overrideStyles(header?: string, content?: string): SmzCellTableBuilder;
+    setBackgroundColor(header?: string, content?: string): SmzCellTableBuilder;
+    setTextColor(header?: string, content?: string): SmzCellTableBuilder;
+    addColumn(property: string, label?: string): SmzCellTableColumnBuilder;
+    setSource(selector?: any, items$?: Observable<any[]>, items?: any[]): SmzCellTableBuilder;
+}
+export declare class SmzCellTableColumnBuilder {
+    _tableBuilder: SmzCellTableBuilder;
+    _documentBuilder: SmzDocumentBuilder;
+    private _data;
+    constructor(_tableBuilder: SmzCellTableBuilder, property: string, label: string, _documentBuilder: SmzDocumentBuilder);
+    setHeight(height: string): SmzCellTableColumnBuilder;
+    setWidth(width: SmzDocumentWidthTypes): SmzCellTableColumnBuilder;
+    overrideStyles(header?: string, content?: string): SmzCellTableColumnBuilder;
+    setBackgroundColor(header?: string, content?: string): SmzCellTableColumnBuilder;
+    setTextColor(header?: string, content?: string): SmzCellTableColumnBuilder;
+    useCentralized(): SmzCellTableColumnBuilder;
+    dataTransform(callback: (value: string, row: any, index: number) => string): SmzCellTableColumnBuilder;
+    get table(): SmzCellTableBuilder;
+}

package/lib/builders/smz-documents/content-cells/title.d.ts

@@ -0,0 +1,20 @@
+import { SmzDocumentCell } from '../../../modules/smz-documents/models/smz-document';
+import { SmzDocumentTitle } from '../../../modules/smz-documents/models/smz-document-features';
+import { SmzDocumentBaseCellBuilder } from '../document-base-cell';
+import { SmzDocumentBuilder } from '../document-builder';
+import { SmzDocumentRowBuilder } from '../document-content';
+export declare class SmzCellTitleBuilder extends SmzDocumentBaseCellBuilder<SmzCellTitleBuilder> {
+    _rowBuilder: SmzDocumentRowBuilder;
+    _cell: SmzDocumentCell;
+    _data: SmzDocumentTitle;
+    _documentBuilder: SmzDocumentBuilder;
+    protected that: this;
+    constructor(_rowBuilder: SmzDocumentRowBuilder, _cell: SmzDocumentCell, _data: SmzDocumentTitle, _documentBuilder: SmzDocumentBuilder);
+    overrideContainerStyles(styleClass: string): SmzCellTitleBuilder;
+    overrideTextStyles(styleClass: string): SmzCellTitleBuilder;
+    addContainerStyles(styleClass: string): SmzCellTitleBuilder;
+    useBorder(): SmzCellTitleBuilder;
+    addTextStyles(styleClass: string): SmzCellTitleBuilder;
+    setBackgroundColor(color: string): SmzCellTitleBuilder;
+    setTextColor(color: string): SmzCellTitleBuilder;
+}

package/lib/builders/smz-documents/document-base-cell.d.ts

@@ -0,0 +1,19 @@
+import { SmzDocumentCell } from '../../modules/smz-documents/models/smz-document';
+import { SmzDocumentBaseCell } from '../../modules/smz-documents/models/smz-document-features';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzDocumentBuilder } from './document-builder';
+import { SmzDocumentRowBuilder } from './document-content';
+export type SmzDocumentWidthTypes = 'auto' | 'col-1' | 'col-2' | 'col-3' | 'col-4' | 'col-5' | 'col-6' | 'col-7' | 'col-8' | 'col-9' | 'col-10' | 'col-11' | 'col-12';
+export declare class SmzDocumentBaseCellBuilder<T> extends SmzBuilderUtilities<T> {
+    _rowBuilder: SmzDocumentRowBuilder;
+    _cell: SmzDocumentCell;
+    _data: SmzDocumentBaseCell;
+    _documentBuilder: SmzDocumentBuilder;
+    protected that: T;
+    constructor(_rowBuilder: SmzDocumentRowBuilder, _cell: SmzDocumentCell, _data: SmzDocumentBaseCell, _documentBuilder: SmzDocumentBuilder);
+    setRowspan(rowsCount: number): T;
+    setColspan(colsCount: number): T;
+    setHeight(height: string): T;
+    setWidth(width: SmzDocumentWidthTypes): T;
+    get row(): SmzDocumentRowBuilder;
+}

package/lib/builders/smz-documents/document-builder.d.ts

@@ -0,0 +1,42 @@
+import { SmzDocumentFontFamilies, SmzDocumentRenderers, SmzDocumentState } from '../../modules/smz-documents/models/smz-document';
+import { SmzDocumentContentBuilder } from './document-content';
+import { SmzDocumentConfig } from '../../modules/smz-documents/models/smz-document-config';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzDocumentViewerBuilder } from './document-viewer';
+import { HTMLOptions, jsPDFOptions } from 'jspdf';
+import { SmzDocumentPageFormats } from '../../modules/smz-documents/models/smz-page-formats';
+export declare class SmzDocumentBuilder extends SmzBuilderUtilities<SmzDocumentBuilder> {
+    protected that: this;
+    private defaultConfig;
+    _state: SmzDocumentState;
+    private applyConfig;
+    private applyMargin;
+    private initJsPDFOptions;
+    private updateHtml2pdfOptions;
+    private setPageConfig;
+    private updateHTMLOptions;
+    constructor(state?: SmzDocumentState);
+    setPaddingCompensation(pixels: number): SmzDocumentBuilder;
+    setPageOverlapCompensation(pixels: number): SmzDocumentBuilder;
+    setUnit(unit: 'mm' | 'cm'): SmzDocumentBuilder;
+    setRenderer(render: SmzDocumentRenderers): SmzDocumentBuilder;
+    setQuality(scale: number): SmzDocumentBuilder;
+    overrideDefaultConfigs(newConfig: SmzDocumentConfig): SmzDocumentBuilder;
+    setPage(format: SmzDocumentPageFormats | number[], orientation: 'portrait' | 'p' | 'l' | 'landscape'): SmzDocumentBuilder;
+    overrideJsPDFOptions(options: jsPDFOptions): SmzDocumentBuilder;
+    overrideHTMLOptions(options: HTMLOptions): SmzDocumentBuilder;
+    setFilename(filename: string): SmzDocumentBuilder;
+    viewer(): SmzDocumentViewerBuilder;
+    pageBreak(): SmzDocumentBuilder;
+    content(): SmzDocumentContentBuilder;
+    header(): SmzDocumentContentBuilder;
+    debugMode(): SmzDocumentBuilder;
+    hidePageNumbers(): SmzDocumentBuilder;
+    hidePrintHour(): SmzDocumentBuilder;
+    setSummaryText(text: string): SmzDocumentBuilder;
+    setPreviewScale(scale: number): SmzDocumentBuilder;
+    setFontFamily(fontFamily: SmzDocumentFontFamilies): SmzDocumentBuilder;
+    setMargins(left?: number, right?: number, top?: number, bottom?: number): SmzDocumentBuilder;
+    setLocale(language: 'pt-BR' | 'en-US'): SmzDocumentBuilder;
+    build(): SmzDocumentState;
+}

package/lib/builders/smz-documents/document-content.d.ts

@@ -0,0 +1,49 @@
+import { SmzDocumentRow, SmzDocumentContent } from '../../modules/smz-documents/models/smz-document';
+import { SmzDocumentBuilder } from './document-builder';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzChart } from '../../modules/smz-charts/models/chart';
+import { SmzCellChartBuilder } from './content-cells/chart';
+import { SmzCellTableBuilder } from './content-cells/table';
+import { SmzCellTitleBuilder } from './content-cells/title';
+import { SmzCellDividerBuilder } from './content-cells/divider';
+import { SmzCellFieldBuilder } from './content-cells/field';
+import { SmzCellFieldsGroupBuilder } from './content-cells/fields-group';
+import { SmzCellImageBuilder } from './content-cells/image';
+import { SmzCellPageBreakBuilder } from './content-cells/page-break';
+import { SmzCellSpacerBuilder } from './content-cells/spacer';
+import { SmzCellSubTitleBuilder } from './content-cells/sub-title';
+import { SmzCellComponentBuilder } from './content-cells/component';
+import { SmzCellHiddenBreakBuilder } from './content-cells/hidden-break';
+export declare class SmzDocumentContentBuilder extends SmzBuilderUtilities<SmzDocumentContentBuilder> {
+    private _documentBuilder;
+    private _content;
+    protected that: this;
+    constructor(_documentBuilder: SmzDocumentBuilder, _content: SmzDocumentContent);
+    pageBreak(): SmzDocumentContentBuilder;
+    row(): SmzDocumentRowBuilder;
+    overrideContainerStyles(styleClass: string): SmzDocumentContentBuilder;
+    addContainerStyles(styleClass: string): SmzDocumentContentBuilder;
+    useFixedLayout(): SmzDocumentContentBuilder;
+    get document(): SmzDocumentBuilder;
+}
+export declare class SmzDocumentRowBuilder extends SmzBuilderUtilities<SmzDocumentRowBuilder> {
+    private _contentBuilder;
+    private _row;
+    private _documentBuilder;
+    private _content;
+    protected that: this;
+    constructor(_contentBuilder: SmzDocumentContentBuilder, _row: SmzDocumentRow, _documentBuilder: SmzDocumentBuilder, _content: SmzDocumentContent);
+    title(text: string): SmzCellTitleBuilder;
+    divider(): SmzCellDividerBuilder;
+    pageBreak(): SmzCellPageBreakBuilder;
+    field(text: string, label?: string): SmzCellFieldBuilder;
+    image(src: string): SmzCellImageBuilder;
+    spacer(): SmzCellSpacerBuilder;
+    hiddenBreak(): SmzCellHiddenBreakBuilder;
+    subTitle(text: string): SmzCellSubTitleBuilder;
+    group(): SmzCellFieldsGroupBuilder;
+    table(): SmzCellTableBuilder;
+    chart(chartData: SmzChart): SmzCellChartBuilder;
+    component(component: any): SmzCellComponentBuilder;
+    get content(): SmzDocumentContentBuilder;
+}

package/lib/builders/smz-documents/document-viewer.d.ts

@@ -0,0 +1,17 @@
+import { SmzDocumentBuilder } from './document-builder';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzDocumentViewer } from '../../modules/smz-documents/models/smz-document-viewer';
+export declare class SmzDocumentViewerBuilder extends SmzBuilderUtilities<SmzDocumentViewerBuilder> {
+    private _documentBuilder;
+    private _viewer;
+    protected that: this;
+    constructor(_documentBuilder: SmzDocumentBuilder, _viewer: SmzDocumentViewer);
+    overrideContainerStyles(styleClass: string): SmzDocumentViewerBuilder;
+    overridePaperStyles(styleClass: string): SmzDocumentViewerBuilder;
+    setZoom(initial: number, min?: number, max?: number, variation?: number): SmzDocumentViewerBuilder;
+    disableZoomControls(): SmzDocumentViewerBuilder;
+    allowOpen(label?: string): SmzDocumentViewerBuilder;
+    allowPrint(label?: string): SmzDocumentViewerBuilder;
+    allowDownload(label?: string): SmzDocumentViewerBuilder;
+    get document(): SmzDocumentBuilder;
+}

package/lib/builders/smz-easy-tables/column-builder.d.ts

@@ -0,0 +1,52 @@
+import { SmzEasyTableContentType } from '../../standalones/easy-table/models/smz-easy-table-contents';
+import { SmzEasyTableBodyColumn, SmzEasyTableHeader } from '../../standalones/easy-table/models/smz-easy-table-state';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzDocumentWidthTypes } from '../smz-documents/document-base-cell';
+import { SmzEasyTableBuilder } from './state-builder';
+export declare abstract class SmzEasyBaseColumnBuilder<T extends SmzEasyBaseColumnBuilder<T>> {
+    protected _table: SmzEasyTableBuilder;
+    protected _parent: SmzEasyColumnCollectionBuilder;
+    _column: SmzEasyTableBodyColumn;
+    _header: SmzEasyTableHeader;
+    constructor(_table: SmzEasyTableBuilder, _parent: SmzEasyColumnCollectionBuilder, type: SmzEasyTableContentType, key: string, header: string);
+    useSort(order: 'asc' | 'desc'): SmzEasyBaseColumnBuilder<T>;
+    hide(): SmzEasyBaseColumnBuilder<T>;
+    setCellStyles(styleClass: string): SmzEasyBaseColumnBuilder<T>;
+    setHeaderStyles(styleClass: string): SmzEasyBaseColumnBuilder<T>;
+    setWidth(widthClass: SmzDocumentWidthTypes): SmzEasyBaseColumnBuilder<T>;
+    get columns(): SmzEasyColumnCollectionBuilder;
+}
+export declare class SmzEasyColumnCollectionBuilder extends SmzBuilderUtilities<SmzEasyColumnCollectionBuilder> {
+    private _tableBuilder;
+    protected that: this;
+    constructor(_tableBuilder: SmzEasyTableBuilder);
+    text(header: string, dataPath: string, key?: string): SmzEasyTextColumnBuilder;
+    custom(header: string, dataPath: string, key: string): SmzEasyCustomColumnBuilder;
+    date(header: string, dataPath: string, key?: string): SmzEasyDateColumnBuilder;
+    dataTransform(header: string, dataPath: string, key?: string): SmzEasyDataTransformColumnBuilder;
+    get table(): SmzEasyTableBuilder;
+}
+export declare class SmzEasyTextColumnBuilder extends SmzEasyBaseColumnBuilder<SmzEasyTextColumnBuilder> {
+    protected _table: SmzEasyTableBuilder;
+    protected _parent: SmzEasyColumnCollectionBuilder;
+    constructor(_table: SmzEasyTableBuilder, _parent: SmzEasyColumnCollectionBuilder, header: string, dataPath: string, key?: string);
+}
+export declare class SmzEasyDateColumnBuilder extends SmzEasyBaseColumnBuilder<SmzEasyDateColumnBuilder> {
+    protected _table: SmzEasyTableBuilder;
+    protected _parent: SmzEasyColumnCollectionBuilder;
+    constructor(_table: SmzEasyTableBuilder, _parent: SmzEasyColumnCollectionBuilder, header: string, dataPath: string, key?: string);
+    setDateFormat(format: 'shortDate' | 'short' | 'medium' | 'long' | 'mediumDate' | 'longDate' | 'shortTime'): SmzEasyDateColumnBuilder;
+}
+export declare class SmzEasyCustomColumnBuilder extends SmzEasyBaseColumnBuilder<SmzEasyCustomColumnBuilder> {
+    protected _table: SmzEasyTableBuilder;
+    protected _parent: SmzEasyColumnCollectionBuilder;
+    constructor(_table: SmzEasyTableBuilder, _parent: SmzEasyColumnCollectionBuilder, header: string, dataPath: string, key?: string);
+    setSearchDataPath(dataPath: string): SmzEasyCustomColumnBuilder;
+}
+export declare class SmzEasyDataTransformColumnBuilder extends SmzEasyBaseColumnBuilder<SmzEasyDataTransformColumnBuilder> {
+    protected _table: SmzEasyTableBuilder;
+    protected _parent: SmzEasyColumnCollectionBuilder;
+    constructor(_table: SmzEasyTableBuilder, _parent: SmzEasyColumnCollectionBuilder, header: string, dataPath: string, key?: string);
+    setCallback(callback: (data: any, row: any, index: number) => string, key?: string): SmzEasyDataTransformColumnBuilder;
+    setSearchAndSortDataPath(dataPath: string): SmzEasyDataTransformColumnBuilder;
+}

package/lib/builders/smz-easy-tables/menu-builder.d.ts

@@ -0,0 +1,33 @@
+import { MenuItem } from 'primeng/api';
+import { SmzMenuItem } from '../../modules/smz-menu/models/smz-menu-item';
+import { SmzDocumentWidthTypes } from '../smz-documents/document-base-cell';
+import { SmzEasyTableBuilder } from './state-builder';
+export declare class SmzEasyMenuTableBuilder {
+    private _tableBuilder;
+    constructor(_tableBuilder: SmzEasyTableBuilder, items?: SmzMenuItem[]);
+    setHeader(header: string): SmzEasyMenuTableBuilder;
+    setWidth(widthClass: SmzDocumentWidthTypes): SmzEasyMenuTableBuilder;
+    setHeaderStyles(styleClass: string): SmzEasyMenuTableBuilder;
+    useDynamic(callback: (row: any) => SmzMenuItem[]): SmzEasyMenuTableBuilder;
+    item(label: string, icon?: string, tooltip?: string): SmzMenuItemEasyTableBuilder;
+    separator(): SmzEasyMenuTableBuilder;
+    get table(): SmzEasyTableBuilder;
+}
+export declare class SmzMenuItemEasyTableBuilder {
+    private _menuBuilder;
+    private _parent;
+    private _item;
+    constructor(_menuBuilder: SmzEasyMenuTableBuilder, _parent: SmzMenuItemEasyTableBuilder, _item: SmzMenuItem);
+    addChild(label: string, icon?: string): SmzMenuItemEasyTableBuilder;
+    setCallback<T>(callback: (item: T) => void): SmzMenuItemEasyTableBuilder;
+    setRedirect(paths: string[]): SmzMenuItemEasyTableBuilder;
+    setVisibilityRule<T>(callback: (item: T) => boolean): SmzMenuItemEasyTableBuilder;
+    setActivationRule<T>(callback: (item: T) => boolean): SmzMenuItemEasyTableBuilder;
+    hide(): SmzMenuItemEasyTableBuilder;
+    disable(): SmzMenuItemEasyTableBuilder;
+    addTransformRule<T>(callback: (item: T) => Partial<MenuItem>): SmzMenuItemEasyTableBuilder;
+    askForConfirmation(title: string, message: string): SmzMenuItemEasyTableBuilder;
+    askForCriticalConfirmation(title: string, message: string): SmzMenuItemEasyTableBuilder;
+    get menu(): SmzEasyMenuTableBuilder;
+    applyChild(): SmzMenuItemEasyTableBuilder;
+}

package/lib/builders/smz-easy-tables/optimizations-builder.d.ts

@@ -0,0 +1,10 @@
+import { SmzEasyTableBuilder } from './state-builder';
+export declare class SmzEasyTableOptimizationsBuilder {
+    private _tableBuilder;
+    constructor(_tableBuilder: SmzEasyTableBuilder);
+    disable(...optimizations: Array<'data-source' | 'global-search'>): SmzEasyTableOptimizationsBuilder;
+    disableDataSourceOtimization(miliseconds: number): SmzEasyTableOptimizationsBuilder;
+    setDataSourceOtimization(method: 'auto' | 'fixed', initialInterval?: number, autoIncrementation?: number): SmzEasyTableOptimizationsBuilder;
+    setGlobalSearchOtimization(initialInterval?: number, autoIncrementation?: number): SmzEasyTableOptimizationsBuilder;
+    get table(): SmzEasyTableBuilder;
+}

package/lib/builders/smz-easy-tables/paginator-builder.d.ts

@@ -0,0 +1,9 @@
+import { SmzEasyTableBuilder } from './state-builder';
+export declare class SmzEasyTablePaginatorBuilder {
+    private _tableBuilder;
+    constructor(_tableBuilder: SmzEasyTableBuilder, itemsPerPage?: number);
+    disable(): SmzEasyTablePaginatorBuilder;
+    hideResults(): SmzEasyTablePaginatorBuilder;
+    setMaxVisiblePages(amount: number): SmzEasyTablePaginatorBuilder;
+    get table(): SmzEasyTableBuilder;
+}

package/lib/builders/smz-easy-tables/state-builder.d.ts

@@ -0,0 +1,26 @@
+import { SmzMenuItem } from '../../modules/smz-menu/models/smz-menu-item';
+import { SmzEasyMenuTableBuilder } from './menu-builder';
+import { SmzEasyTableBodyColumn, SmzEasyTableHeader, SmzEasyTableState } from '../../standalones/easy-table/models/smz-easy-table-state';
+import { SmzEasyColumnCollectionBuilder } from './column-builder';
+import { SmzEasyTablePaginatorBuilder } from './paginator-builder';
+import { SmzEasyTableOptimizationsBuilder } from './optimizations-builder';
+export declare class SmzEasyTableBuilder {
+    _state: SmzEasyTableState;
+    _tempMenu: {
+        column: SmzEasyTableBodyColumn;
+        header: SmzEasyTableHeader;
+    };
+    constructor(uiDefinitionName?: string);
+    setTitle(title: string): SmzEasyTableBuilder;
+    setDynamicTitle(callback: () => string): SmzEasyTableBuilder;
+    setLocale(language: 'pt-BR' | 'en-US'): SmzEasyTableBuilder;
+    setEmptyMessage(message: string): SmzEasyTableBuilder;
+    paginator(itemsPerPage?: number): SmzEasyTablePaginatorBuilder;
+    optimize(): SmzEasyTableOptimizationsBuilder;
+    setDataIdProperty(property: string): SmzEasyTableBuilder;
+    setSize(size: 'small' | 'regular' | 'large'): SmzEasyTableBuilder;
+    menu(items?: SmzMenuItem[]): SmzEasyMenuTableBuilder;
+    columns(): SmzEasyColumnCollectionBuilder;
+    debugMode(): SmzEasyTableBuilder;
+    build(): SmzEasyTableState;
+}

package/lib/builders/smz-excels/excels-builder.d.ts

@@ -0,0 +1,20 @@
+import { SmzExcelState } from '../../modules/smz-excels/models/smz-excel-table';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzExcelsSheetsBuilder } from './excels-sheets';
+export declare class SmzExcelsBuilder extends SmzBuilderUtilities<SmzExcelsBuilder> {
+    protected that: this;
+    private defaultConfig;
+    _state: SmzExcelState;
+    constructor();
+    setFilename(fileName: string): SmzExcelsBuilder;
+    setInfo(title: string): SmzExcelsBuilder;
+    setAuthor(author: string): SmzExcelsBuilder;
+    setCompany(company: string): SmzExcelsBuilder;
+    setComments(comments: string): SmzExcelsBuilder;
+    setGlobalDateFormat(format: string): SmzExcelsBuilder;
+    setGlobalNewLineSeparator(separator: string): SmzExcelsBuilder;
+    setGlobalHyperlinkAsHtml(): SmzExcelsBuilder;
+    sheet(name: string): SmzExcelsSheetsBuilder;
+    debugMode(): SmzExcelsBuilder;
+    build(): SmzExcelState;
+}

package/lib/builders/smz-excels/excels-sheets.d.ts

@@ -0,0 +1,14 @@
+import { SmzExcelState, SmzExcelTableSheet } from '../../modules/smz-excels/models/smz-excel-table';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzExcelsBuilder } from './excels-builder';
+import { SmzExcelsTablesBuilder } from './excels-tables';
+export declare class SmzExcelsSheetsBuilder extends SmzBuilderUtilities<SmzExcelsSheetsBuilder> {
+    private _builder;
+    private _;
+    private _state;
+    protected that: this;
+    constructor(_builder: SmzExcelsBuilder, _: SmzExcelState, _state: SmzExcelTableSheet);
+    setColor(hexColor: string): SmzExcelsSheetsBuilder;
+    table(): SmzExcelsTablesBuilder;
+    get excels(): SmzExcelsBuilder;
+}

package/lib/builders/smz-excels/excels-styles.d.ts

@@ -0,0 +1,12 @@
+import { SmzExcelFontDefinitions } from '../../modules/smz-excels/models/smz-excel-definitions';
+import { SmzExcelStyle } from '../../modules/smz-excels/models/smz-excel-table';
+export declare class SmzExcelsStylesBuilder<T> {
+    private _builder;
+    private _state;
+    constructor(_builder: T, _state: SmzExcelStyle);
+    setFont(font: SmzExcelFontDefinitions): SmzExcelsStylesBuilder<T>;
+    setFontSize(fontSize: number): SmzExcelsStylesBuilder<T>;
+    enableBold(): SmzExcelsStylesBuilder<T>;
+    enableItalic(): SmzExcelsStylesBuilder<T>;
+    get apply(): T;
+}

package/lib/builders/smz-excels/excels-table-base-column-content.d.ts

@@ -0,0 +1,59 @@
+import { SmzExcelColumn } from '../../modules/smz-excels/models/smz-excel-table';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzExcelsTableColumnsBuilder } from './excels-table-columns';
+export declare class SmzExcelsTableColumnTextBuilder extends SmzBuilderUtilities<SmzExcelsTableColumnTextBuilder> {
+    protected _builder: SmzExcelsTableColumnsBuilder;
+    protected _state: SmzExcelColumn;
+    protected that: this;
+    constructor(_builder: SmzExcelsTableColumnsBuilder, _state: SmzExcelColumn);
+    setMaxWidthInPixels(maxWidth: number, resolution?: number): SmzExcelsTableColumnTextBuilder;
+    setMaxWidthInPoints(maxWidth: number): SmzExcelsTableColumnTextBuilder;
+    setAsMultilined(overrideNewlineSeparator?: string): SmzExcelsTableColumnTextBuilder;
+    get column(): SmzExcelsTableColumnsBuilder;
+}
+export declare class SmzExcelsTableColumnDateBuilder extends SmzBuilderUtilities<SmzExcelsTableColumnDateBuilder> {
+    protected _builder: SmzExcelsTableColumnsBuilder;
+    protected _state: SmzExcelColumn;
+    protected that: this;
+    constructor(_builder: SmzExcelsTableColumnsBuilder, _state: SmzExcelColumn);
+    setMaxWidthInPixels(maxWidth: number, resolution?: number): SmzExcelsTableColumnDateBuilder;
+    setMaxWidthInPoints(maxWidth: number): SmzExcelsTableColumnDateBuilder;
+    setDateFormat(dataFormat: string): SmzExcelsTableColumnDateBuilder;
+    setAsMultilined(overrideNewlineSeparator?: string): SmzExcelsTableColumnDateBuilder;
+    get column(): SmzExcelsTableColumnsBuilder;
+}
+export declare class SmzExcelsTableColumnAutoDetectBuilder extends SmzBuilderUtilities<SmzExcelsTableColumnAutoDetectBuilder> {
+    protected _builder: SmzExcelsTableColumnsBuilder;
+    protected _state: SmzExcelColumn;
+    protected that: this;
+    constructor(_builder: SmzExcelsTableColumnsBuilder, _state: SmzExcelColumn);
+    setMaxWidthInPixels(maxWidth: number, resolution?: number): SmzExcelsTableColumnAutoDetectBuilder;
+    setMaxWidthInPoints(maxWidth: number): SmzExcelsTableColumnAutoDetectBuilder;
+    setAsMultilined(overrideNewlineSeparator?: string): SmzExcelsTableColumnAutoDetectBuilder;
+    get column(): SmzExcelsTableColumnsBuilder;
+}
+export declare class SmzExcelsTableColumnNumberBuilder extends SmzBuilderUtilities<SmzExcelsTableColumnNumberBuilder> {
+    protected _builder: SmzExcelsTableColumnsBuilder;
+    protected _state: SmzExcelColumn;
+    protected that: this;
+    constructor(_builder: SmzExcelsTableColumnsBuilder, _state: SmzExcelColumn);
+    useCurrencyFormat(currencySymbol?: string): SmzExcelsTableColumnNumberBuilder;
+    usePercentageFormat(): SmzExcelsTableColumnNumberBuilder;
+    setCustomFormat(format: string): SmzExcelsTableColumnNumberBuilder;
+    setMaxWidthInPixels(maxWidth: number, resolution?: number): SmzExcelsTableColumnNumberBuilder;
+    setMaxWidthInPoints(maxWidth: number): SmzExcelsTableColumnNumberBuilder;
+    setFormat(format: string): SmzExcelsTableColumnNumberBuilder;
+    useSubTotal(): SmzExcelsTableColumnNumberBuilder;
+    setAsMultilined(overrideNewlineSeparator?: string): SmzExcelsTableColumnNumberBuilder;
+    get column(): SmzExcelsTableColumnsBuilder;
+}
+export declare class SmzExcelsTableColumnHyperlinkBuilder extends SmzBuilderUtilities<SmzExcelsTableColumnHyperlinkBuilder> {
+    protected _builder: SmzExcelsTableColumnsBuilder;
+    protected _state: SmzExcelColumn;
+    protected that: this;
+    constructor(_builder: SmzExcelsTableColumnsBuilder, _state: SmzExcelColumn);
+    setMaxWidthInPixels(maxWidth: number, resolution?: number): SmzExcelsTableColumnHyperlinkBuilder;
+    setMaxWidthInPoints(maxWidth: number): SmzExcelsTableColumnHyperlinkBuilder;
+    setAsMultilined(overrideNewlineSeparator?: string): SmzExcelsTableColumnHyperlinkBuilder;
+    get column(): SmzExcelsTableColumnsBuilder;
+}

package/lib/builders/smz-excels/excels-table-columns.d.ts

@@ -0,0 +1,21 @@
+import { SmzExcelSortOrderDefinitions } from '../../modules/smz-excels/models/smz-excel-definitions';
+import { SmzExcelState, SmzExcelTableSheet } from '../../modules/smz-excels/models/smz-excel-table';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzExcelsTableColumnAutoDetectBuilder, SmzExcelsTableColumnDateBuilder, SmzExcelsTableColumnHyperlinkBuilder, SmzExcelsTableColumnNumberBuilder, SmzExcelsTableColumnTextBuilder } from './excels-table-base-column-content';
+import { SmzExcelsTablesBuilder } from './excels-tables';
+export declare class SmzExcelsTableColumnsBuilder extends SmzBuilderUtilities<SmzExcelsTableColumnsBuilder> {
+    private _builder;
+    _: SmzExcelState;
+    private _state;
+    protected that: this;
+    private _dataProperties;
+    private defaultColumn;
+    constructor(_builder: SmzExcelsTablesBuilder, _: SmzExcelState, _state: SmzExcelTableSheet);
+    auto(dataPropertyPath: string, header: string, sort?: SmzExcelSortOrderDefinitions): SmzExcelsTableColumnAutoDetectBuilder;
+    text(dataPropertyPath: string, header: string, sort?: SmzExcelSortOrderDefinitions): SmzExcelsTableColumnTextBuilder;
+    number(dataPropertyPath: string, header: string, sort?: SmzExcelSortOrderDefinitions): SmzExcelsTableColumnNumberBuilder;
+    hyperlink(dataPropertyPath: string, header: string, sort?: SmzExcelSortOrderDefinitions): SmzExcelsTableColumnHyperlinkBuilder;
+    date(dataPropertyPath: string, header: string, sort?: SmzExcelSortOrderDefinitions): SmzExcelsTableColumnDateBuilder;
+    setData(items: any[]): SmzExcelsTableColumnsBuilder;
+    get table(): SmzExcelsTablesBuilder;
+}