@ngx-smz/core 19.2.0

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

@@ -0,0 +1,25 @@
+import { SmzBaseColumnBuilder } from './column-builder';
+import { SmzTableBuilder } from './state-builder';
+import { SmzTableColumn } from '../../modules/smz-tables/models/table-column';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+export declare class SmzContentActionsBuilder<TColumn extends SmzBaseColumnBuilder<TColumn, TData>, TData> extends SmzBuilderUtilities<SmzContentActionsBuilder<TColumn, TData>> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _parent: SmzBaseColumnBuilder<TColumn, TData>;
+    protected that: this;
+    constructor(_table: SmzTableBuilder<TData>, _parent: SmzBaseColumnBuilder<TColumn, TData>);
+    add(icon: string, callback: (item: any) => void): SmzContentActionIconBuilder<TColumn, TData>;
+    placeAtBeginning(): SmzContentActionsBuilder<TColumn, TData>;
+    get column(): SmzBaseColumnBuilder<TColumn, TData>;
+}
+export declare class SmzContentActionIconBuilder<TColumn extends SmzBaseColumnBuilder<TColumn, TData>, TData> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _column: SmzTableColumn;
+    protected _parent: SmzContentActionsBuilder<TColumn, TData>;
+    private _action;
+    constructor(_table: SmzTableBuilder<TData>, _column: SmzTableColumn, _parent: SmzContentActionsBuilder<TColumn, TData>, icon: string, callback?: (item: any) => void);
+    setStyleClass(styleClass: string): SmzContentActionIconBuilder<TColumn, TData>;
+    setTooltip(tooltip: (item: any) => string): SmzContentActionIconBuilder<TColumn, TData>;
+    condition(condition: (item: any) => boolean): SmzContentActionIconBuilder<TColumn, TData>;
+    callback(callback: (item: any) => boolean): SmzContentActionIconBuilder<TColumn, TData>;
+    get action(): SmzContentActionsBuilder<TColumn, TData>;
+}

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

@@ -0,0 +1,25 @@
+import { SmzBaseColumnBuilder } from './column-builder';
+import { SmzTableBuilder } from './state-builder';
+import { SmzTableColumn } from '../../modules/smz-tables/models/table-column';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+export declare class SmzHeaderActionsBuilder<TColumn extends SmzBaseColumnBuilder<TColumn, TData>, TData> extends SmzBuilderUtilities<SmzHeaderActionsBuilder<TColumn, TData>> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _parent: SmzBaseColumnBuilder<TColumn, TData>;
+    protected that: this;
+    constructor(_table: SmzTableBuilder<TData>, _parent: SmzBaseColumnBuilder<TColumn, TData>);
+    add(icon: string, callback: (item: any) => void): SmzContentActionIconBuilder<TColumn, TData>;
+    setVisibility(visibilityCondition: boolean): SmzHeaderActionsBuilder<TColumn, TData>;
+    get column(): SmzBaseColumnBuilder<TColumn, TData>;
+}
+export declare class SmzContentActionIconBuilder<TColumn extends SmzBaseColumnBuilder<TColumn, TData>, TData> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _column: SmzTableColumn;
+    protected _parent: SmzHeaderActionsBuilder<TColumn, TData>;
+    private _action;
+    constructor(_table: SmzTableBuilder<TData>, _column: SmzTableColumn, _parent: SmzHeaderActionsBuilder<TColumn, TData>, icon: string, callback?: (item: any) => void);
+    setStyleClass(styleClass: string): SmzContentActionIconBuilder<TColumn, TData>;
+    setTooltip(tooltip: (item: any) => string): SmzContentActionIconBuilder<TColumn, TData>;
+    condition(condition: (item: any) => boolean): SmzContentActionIconBuilder<TColumn, TData>;
+    callback(callback: (item: any) => boolean): SmzContentActionIconBuilder<TColumn, TData>;
+    get action(): SmzHeaderActionsBuilder<TColumn, TData>;
+}

package/lib/builders/smz-tables/editable-builder.d.ts

@@ -0,0 +1,74 @@
+import { EditableChanges } from '../../modules/smz-tables/models/editable-model';
+import { SmzEditableType } from '../../modules/smz-tables/models/editable-types';
+import { SmzTableEditableColumn } from '../../modules/smz-tables/models/table-column';
+import { SmzBaseColumnBuilder } from './column-builder';
+import { SmzTableBuilder } from './state-builder';
+export declare class SmzEditableTableBuilder<TData> {
+    private _tableBuilder;
+    constructor(_tableBuilder: SmzTableBuilder<TData>);
+    useFlattenResults<T>(): SmzEditableTableBuilder<TData>;
+    addMappingResults<T>(mapFunction: (data: T, changes: EditableChanges<T>) => any): SmzEditableTableBuilder<TData>;
+    setCreationAction(action: any, claim?: string, overrideActionPayload?: (row: any) => any): SmzEditableTableBuilder<TData>;
+    onCreationInit(onInit: () => void): SmzEditableTableBuilder<TData>;
+    setUpdateAction(action: any, claim?: string, overrideActionPayload?: (row: any) => any): SmzEditableTableBuilder<TData>;
+    setUpdateActionCondition(callback: (row: TData) => boolean): SmzEditableTableBuilder<TData>;
+    setRemoveActionCondition(callback: (row: TData) => boolean): SmzEditableTableBuilder<TData>;
+    onUpdateInit(onInit: (row: any) => void): SmzEditableTableBuilder<TData>;
+    setRemoveAction(action: any, claim?: string, overrideActionPayload?: (row: any) => any): SmzEditableTableBuilder<TData>;
+    onRemoveInit(onInit: (row: any) => void): SmzEditableTableBuilder<TData>;
+    get table(): SmzTableBuilder<TData>;
+}
+export declare abstract class SmzBaseEditableBuilder<T extends SmzBaseEditableBuilder<T, TData>, TData> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _parent: SmzBaseColumnBuilder<any, TData>;
+    protected _editable: SmzTableEditableColumn;
+    constructor(_table: SmzTableBuilder<TData>, _parent: SmzBaseColumnBuilder<any, TData>, type: SmzEditableType, property: string, data: any);
+    disableUpdate(): SmzBaseEditableBuilder<T, TData>;
+    disableCreation(): SmzBaseEditableBuilder<T, TData>;
+    removeRequirement(): SmzBaseEditableBuilder<T, TData>;
+    setMinValidator(min: number): SmzBaseEditableBuilder<T, TData>;
+    setMinLengthValidator(minLength: number): SmzBaseEditableBuilder<T, TData>;
+    setMaxValidator(max: number): SmzBaseEditableBuilder<T, TData>;
+    setMaxLengthValidator(maxLength: number): SmzBaseEditableBuilder<T, TData>;
+    get column(): SmzBaseColumnBuilder<any, TData>;
+}
+export declare class SmzEditableCollectionBuilder<TData> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _parent: SmzBaseColumnBuilder<any, TData>;
+    constructor(_table: SmzTableBuilder<TData>, _parent: SmzBaseColumnBuilder<any, TData>);
+    text(property?: string): SmzTextEditableBuilder<TData>;
+    switch(property?: string): SmzSwitchEditableBuilder<TData>;
+    dropdown(property?: string): SmzDropdownEditableBuilder<TData>;
+    number(property?: string): SmzNumberEditableBuilder<TData>;
+    get column(): SmzBaseColumnBuilder<any, TData>;
+}
+export declare class SmzTextEditableBuilder<TData> extends SmzBaseEditableBuilder<SmzTextEditableBuilder<TData>, TData> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _parent: SmzBaseColumnBuilder<any, TData>;
+    constructor(_table: SmzTableBuilder<TData>, _parent: SmzBaseColumnBuilder<any, TData>, property: string);
+}
+export declare class SmzSwitchEditableBuilder<TData> extends SmzBaseEditableBuilder<SmzSwitchEditableBuilder<TData>, TData> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _parent: SmzBaseColumnBuilder<any, TData>;
+    constructor(_table: SmzTableBuilder<TData>, _parent: SmzBaseColumnBuilder<any, TData>, property: string);
+}
+export declare class SmzDropdownEditableBuilder<TData> extends SmzBaseEditableBuilder<SmzDropdownEditableBuilder<TData>, TData> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _parent: SmzBaseColumnBuilder<any, TData>;
+    constructor(_table: SmzTableBuilder<TData>, _parent: SmzBaseColumnBuilder<any, TData>, property: string, placeholder?: string);
+    setOptions(options: any[]): SmzDropdownEditableBuilder<TData>;
+    setSelector(selector: any): SmzDropdownEditableBuilder<TData>;
+}
+export declare class SmzNumberEditableBuilder<TData> extends SmzBaseEditableBuilder<SmzNumberEditableBuilder<TData>, TData> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _parent: SmzBaseColumnBuilder<any, TData>;
+    constructor(_table: SmzTableBuilder<TData>, _parent: SmzBaseColumnBuilder<any, TData>, property: string);
+    setDecimal(digits: number): SmzNumberEditableBuilder<TData>;
+    setFraction(minFractionDigits: number, maxFractionDigits: number): SmzNumberEditableBuilder<TData>;
+    addPrefix(prefix: string): SmzNumberEditableBuilder<TData>;
+    addSufix(suffix: string): SmzNumberEditableBuilder<TData>;
+    showSpinners(): SmzNumberEditableBuilder<TData>;
+    showClear(): SmzNumberEditableBuilder<TData>;
+    forbidEmpty(): SmzNumberEditableBuilder<TData>;
+    useGrouping(): SmzNumberEditableBuilder<TData>;
+}

package/lib/builders/smz-tables/excel-builder.d.ts

@@ -0,0 +1,16 @@
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzTableBuilder } from './state-builder';
+export declare class SmzTableExcelBuilder<TData> extends SmzBuilderUtilities<SmzTableExcelBuilder<TData>> {
+    private _builder;
+    protected that: this;
+    constructor(_builder: SmzTableBuilder<TData>);
+    setFilename(filename: string): SmzTableExcelBuilder<TData>;
+    useHyperlinkAsHtml(): SmzTableExcelBuilder<TData>;
+    setDateFormat(format: string): SmzTableExcelBuilder<TData>;
+    setGlobalNewLineSeparator(separator: string): SmzTableExcelBuilder<TData>;
+    setMaxFilenameLength(length: number): SmzTableExcelBuilder<TData>;
+    setShortenSuffix(suffix: string): SmzTableExcelBuilder<TData>;
+    setUserAsAuthor(): SmzTableExcelBuilder<TData>;
+    setSheetName(sheetName: string): SmzTableExcelBuilder<TData>;
+    get excel(): SmzTableBuilder<TData>;
+}

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

@@ -0,0 +1,36 @@
+import { MenuItem } from 'primeng/api';
+import { SmzMenuItem } from '../../modules/smz-menu/models/smz-menu-item';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzTableBuilder } from './state-builder';
+export declare class SmzMenuTableBuilder<TData, TMappedData> extends SmzBuilderUtilities<SmzMenuTableBuilder<TData, TMappedData>> {
+    private _tableBuilder;
+    protected that: this;
+    constructor(_tableBuilder: SmzTableBuilder<TData>);
+    item(label?: string, icon?: string, tooltip?: string): SmzMenuItemTableBuilder<SmzMenuTableBuilder<TData, TMappedData>, TData, TMappedData>;
+    separator(): SmzMenuTableBuilder<TData, TMappedData>;
+    useInline(minWidth?: string): SmzMenuTableBuilder<TData, TMappedData>;
+    get table(): SmzTableBuilder<TData>;
+}
+export declare class SmzMenuItemTableBuilder<TBuilder, TData, TMappedData = TData> extends SmzBuilderUtilities<SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>> {
+    private _builder;
+    private _parent;
+    private _item;
+    protected that: this;
+    constructor(_builder: TBuilder, _parent: SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>, _item: SmzMenuItem);
+    addChild(label: string, icon?: string): SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>;
+    setCallback(callback: (item: TMappedData) => void): SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>;
+    setRedirect(paths: string[]): SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>;
+    setVisibilityRule(callback: (item: TMappedData) => boolean): SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>;
+    setActivationRule(callback: (item: TMappedData) => boolean): SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>;
+    hide(): SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>;
+    disable(): SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>;
+    addTransformRule<T>(callback: (item: T) => Partial<MenuItem>): SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>;
+    setDataMapping(callback: (item: TData) => TMappedData): SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>;
+    askForConfirmation(title: string, message: string): SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>;
+    askForCriticalConfirmation(title: string, message: string): SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>;
+    setIcon(icon: string): SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>;
+    setStyles(styleClass: string): SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>;
+    setTooltip(message: string): SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>;
+    get menu(): TBuilder;
+    applyChild(): SmzMenuItemTableBuilder<TBuilder, TData, TMappedData>;
+}

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

@@ -0,0 +1,6 @@
+import { InputConfig } from '../smz-dialogs/dialog-input-conversion';
+import { SmzControlTypes } from '../../modules/smz-forms/models/control-types';
+import { SmzTableState } from '../../modules/smz-tables/models/table-state';
+export declare namespace StateBuilderFunctions {
+    function createColumnsFromInputControls(_state: SmzTableState, inputs: InputConfig[], children: SmzControlTypes[]): void;
+}

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

@@ -0,0 +1,121 @@
+import { SmzMenuItem } from '../../modules/smz-menu/models/smz-menu-item';
+import { SmzTableState } from '../../modules/smz-tables/models/table-state';
+import { SmzColumnCollectionBuilder } from './column-builder';
+import { SmzMenuTableBuilder } from './menu-builder';
+import { SmzBatchMenuBuilder } from './batch-menu-builder';
+import { SmzEditableTableBuilder } from './editable-builder';
+import { Observable } from 'rxjs';
+import { SmzTableExcelBuilder } from './excel-builder';
+import { SmzTableViewportBuilder } from './viewport';
+import { SmzCaptionButtonsBuilder } from './caption-buttons-builder';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+export declare class SmzTableBuilder<TData> extends SmzBuilderUtilities<SmzTableBuilder<TData>> {
+    protected that: this;
+    _state: SmzTableState;
+    constructor(uiDefinitionName?: string);
+    setTitle(title: string): SmzTableBuilder<TData>;
+    addSource(items$: Observable<any[]>): SmzTableBuilder<TData>;
+    enableGlobalFilter(): SmzTableBuilder<TData>;
+    expandGlobalFilterInput(): SmzTableBuilder<TData>;
+    enableColumnVisibility(showColumnHideButton?: boolean): SmzTableBuilder<TData>;
+    setLocale(language: 'pt-BR' | 'en-US'): SmzTableBuilder<TData>;
+    setPaginatorTemplate(template: string): SmzTableBuilder<TData>;
+    enableClearFilters(): SmzTableBuilder<TData>;
+    enableExportToPdf(): SmzTableBuilder<TData>;
+    setClearFilterCallback(callback: () => void): SmzTableBuilder<TData>;
+    setToolbarAlignment(alignment: 'start' | 'end'): SmzTableBuilder<TData>;
+    buttons(): SmzCaptionButtonsBuilder<TData>;
+    /**
+     * Enables the checkbox for multiselection in the table
+     * The user cannot disable this feature
+     */
+    allowDefaultMultiSelection(): SmzTableBuilder<TData>;
+    /**
+   * Enables the checkbox for multiselection in the table
+   * and a creates a button to allow the user to disable the selection mode
+   */
+    allowUserMultiSelection(initialState?: 'enabled' | 'disabled'): SmzTableBuilder<TData>;
+    /**
+     * The table will emit a validation statement through the variable isValid
+     * So that the Dialog can control the submit button based on that
+     * If the user select one or more items the table will be valid
+     * otherwise the table is always invalid.
+     */
+    setSelectionAsRequired(): SmzTableBuilder<TData>;
+    /**
+     * This callback is called when the user click on the selection activation button
+     * and everytime a selection changes
+     */
+    setMultiSelectionCallback(callback: (selection: any[]) => void): SmzTableBuilder<TData>;
+    setMultiSelectioncolumnWidth(width: string): SmzTableBuilder<TData>;
+    allowDefaultRowExpansion(): SmzTableBuilder<TData>;
+    allowRowExpansion(label?: string, initialState?: 'enabled' | 'disabled'): SmzTableBuilder<TData>;
+    disableRowExpansionSincronization(): SmzTableBuilder<TData>;
+    setNewItemsMessage(label: string): SmzTableBuilder<TData>;
+    hideNewItemsMessage(): SmzTableBuilder<TData>;
+    setRowExpansionCallback(callback: () => void): SmzTableBuilder<TData>;
+    setRowExpansionColumnWidth(pixels: number): SmzTableBuilder<TData>;
+    hideHeader(): SmzTableBuilder<TData>;
+    setSkeletonRowsCount(rows: number): SmzTableBuilder<TData>;
+    setEmptyFeedbackMessage(message: string): SmzTableBuilder<TData>;
+    useTableEmptyMessage(): SmzTableBuilder<TData>;
+    setEmptyFeedbackExtraInfo(text: string): SmzTableBuilder<TData>;
+    addEmptyFeedbackButton(label: string, callback: () => void, icon?: string): SmzTableBuilder<TData>;
+    setEmptyFeedbackImage(path: string): SmzTableBuilder<TData>;
+    usePagination(): SmzTableBuilder<TData>;
+    setPaginationDefaultRows(value: number): SmzTableBuilder<TData>;
+    setPaginationPageOptions(value: number[]): SmzTableBuilder<TData>;
+    setPaginationInitialPage(page: number): SmzTableBuilder<TData>;
+    hidePaginationReport(): SmzTableBuilder<TData>;
+    setPaginationReportTemplateText(template: string): SmzTableBuilder<TData>;
+    setInitialSorting(field: string, order: 1 | -1): SmzTableBuilder<TData>;
+    setCustomInitialSorting(data: {
+        field?: string;
+        mode?: 'single' | 'multiple';
+        order?: 1 | -1;
+        multiSortMeta?: {
+            field: string;
+            order: 1 | -1;
+        }[];
+    }): SmzTableBuilder<TData>;
+    useStrippedStyle(): SmzTableBuilder<TData>;
+    useGridStyle(): SmzTableBuilder<TData>;
+    setSize(size: 'extra-small' | 'small' | 'regular' | 'large'): SmzTableBuilder<TData>;
+    useEstimatedColWidth(maxWidthPx?: number): SmzTableBuilder<TData>;
+    setEstimatedSamplesCount(samplesCount: number): SmzTableBuilder<TData>;
+    setEstimatedFontBase(fontBase: string): SmzTableBuilder<TData>;
+    setEstimatedPadding(padding: number): SmzTableBuilder<TData>;
+    setTableStyleClass(styleClass: string): SmzTableBuilder<TData>;
+    reorder(...properties: string[]): SmzTableBuilder<TData>;
+    relabel(...operations: {
+        property: string;
+        header: string;
+    }[]): SmzTableBuilder<TData>;
+    resizeIgnoringCheck(...operations: {
+        property: string;
+        width: string;
+    }[]): SmzTableBuilder<TData>;
+    resize(...operations: {
+        property: string;
+        width: string;
+    }[]): SmzTableBuilder<TData>;
+    useCustomActions(columnWidthPixels: number): SmzTableBuilder<TData>;
+    disableRowHoverEffect(): SmzTableBuilder<TData>;
+    setRowClickCallback<T>(callback: (event: T) => void): SmzTableBuilder<TData>;
+    expandOnRowClick(): SmzTableBuilder<TData>;
+    setHighlightedRows(ids: string[]): SmzTableBuilder<TData>;
+    setPreserveLayoutInSmallDevices(): SmzTableBuilder<TData>;
+    setCellStyleClass(styleClass: string): SmzTableBuilder<TData>;
+    menu(items?: SmzMenuItem[]): SmzMenuTableBuilder<TData, TData>;
+    dynamicMenu(callback: (row: any) => SmzMenuItem[]): SmzTableBuilder<TData>;
+    batchMenu(items?: SmzMenuItem[]): SmzBatchMenuBuilder<TData>;
+    editable(): SmzEditableTableBuilder<TData>;
+    setScrollDirection(direction?: 'vertical' | 'horizontal' | 'both'): SmzTableBuilder<TData>;
+    useVerticalScrollHeight(height: string): SmzTableBuilder<TData>;
+    debugMode(): SmzTableBuilder<TData>;
+    columns(): SmzColumnCollectionBuilder<TData>;
+    viewport(): SmzTableViewportBuilder<TData>;
+    excel(): SmzTableExcelBuilder<TData>;
+    build(): SmzTableState;
+}
+export declare function applyTableContentNgStyle(state: SmzTableState, size: number, finalWidth?: string): any;

package/lib/builders/smz-tables/viewport.d.ts

@@ -0,0 +1,15 @@
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzTableBuilder } from './state-builder';
+import { SmzTableViewportStateData } from '../../modules/smz-tables/models/table-state';
+export declare class SmzTableViewportBuilder<TData> extends SmzBuilderUtilities<SmzTableViewportBuilder<TData>> {
+    private _tableBuilder;
+    protected that: this;
+    constructor(_tableBuilder: SmzTableBuilder<TData>);
+    usePersistenceGlobally(key: string): SmzTableViewportBuilder<TData>;
+    usePersistenceByUser(key: string): SmzTableViewportBuilder<TData>;
+    useManualPersistence(load: () => SmzTableViewportStateData, save: (state: SmzTableViewportStateData) => void): SmzTableViewportBuilder<TData>;
+    saveTriggerOnChange(): SmzTableViewportBuilder<TData>;
+    hookChanges(callback: (state: SmzTableViewportStateData) => void): SmzTableViewportBuilder<TData>;
+    applyData(state: SmzTableViewportStateData): SmzTableViewportBuilder<TData>;
+    get table(): SmzTableBuilder<TData>;
+}

package/lib/builders/smz-timeline/menu-builder.d.ts

@@ -0,0 +1,35 @@
+import { MenuItem } from 'primeng/api';
+import { SmzCardActions } from '../../modules/smz-cards/models/smz-cards-state';
+import { SmzMenuItem } from '../../modules/smz-menu/models/smz-menu-item';
+import { SmzTimelineBuilder } from './state-builder';
+export declare class SmzTimelineMenuBuilder {
+    private _cardsBuilder;
+    protected _action: SmzCardActions<any>;
+    items: SmzMenuItem[];
+    constructor(_cardsBuilder: SmzTimelineBuilder<any>, _action: SmzCardActions<any>, items?: SmzMenuItem[]);
+    useDynamic(callback: (row: any) => SmzMenuItem[]): SmzTimelineMenuBuilder;
+    item(label: string, icon?: string, tooltip?: string): SmzMenuItemCardsBuilder;
+    separator(): SmzTimelineMenuBuilder;
+    get timeline(): SmzTimelineBuilder<any>;
+    setButtonClass(style: string): SmzTimelineMenuBuilder;
+    setIcon(style: string): SmzTimelineMenuBuilder;
+    setStyleClass(style: string): SmzTimelineMenuBuilder;
+}
+export declare class SmzMenuItemCardsBuilder {
+    private _menuBuilder;
+    private _parent;
+    private _item;
+    constructor(_menuBuilder: SmzTimelineMenuBuilder, _parent: SmzMenuItemCardsBuilder, _item: SmzMenuItem);
+    addChild(label: string, icon?: string): SmzMenuItemCardsBuilder;
+    setCallback<T>(callback: (item: T) => void): SmzMenuItemCardsBuilder;
+    setRedirect(paths: string[]): SmzMenuItemCardsBuilder;
+    setVisibilityRule<T>(callback: (item: T) => boolean): SmzMenuItemCardsBuilder;
+    setActivationRule<T>(callback: (item: T) => boolean): SmzMenuItemCardsBuilder;
+    hide(): SmzMenuItemCardsBuilder;
+    disable(): SmzMenuItemCardsBuilder;
+    addTransformRule<T>(callback: (item: T) => Partial<MenuItem>): SmzMenuItemCardsBuilder;
+    askForConfirmation(title: string, message: string): SmzMenuItemCardsBuilder;
+    askForCriticalConfirmation(title: string, message: string): SmzMenuItemCardsBuilder;
+    get menu(): SmzTimelineMenuBuilder;
+    applyChild(): SmzMenuItemCardsBuilder;
+}

package/lib/builders/smz-timeline/source-builder.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+import { SmzTimelineBuilder } from './state-builder';
+export declare class SmzTimelineSourcesBuilder<TItem> {
+    private _builder;
+    constructor(_builder: SmzTimelineBuilder<TItem>);
+    addSource(items$: Observable<TItem[]>, label: string): SmzTimelineSourceBuilder<TItem>;
+    get timeline(): SmzTimelineBuilder<any>;
+}
+export declare class SmzTimelineSourceBuilder<TItem> {
+    protected _cardsBuilder: SmzTimelineBuilder<TItem>;
+    protected _sourcesBuilder: SmzTimelineSourcesBuilder<TItem>;
+    private sourceData;
+    private allowed;
+    private restricted;
+    constructor(_cardsBuilder: SmzTimelineBuilder<TItem>, _sourcesBuilder: SmzTimelineSourcesBuilder<TItem>, items$: Observable<TItem[]>, label: string);
+    setAsDefault(): SmzTimelineSourceBuilder<TItem>;
+    allowTo(allowedClaim: string): SmzTimelineSourceBuilder<TItem>;
+    restrictTo(restrictedClaim: string): SmzTimelineSourceBuilder<TItem>;
+    get source(): SmzTimelineSourcesBuilder<TItem>;
+}

package/lib/builders/smz-timeline/state-builder.d.ts

@@ -0,0 +1,24 @@
+import { SmzMenuItem } from '../../modules/smz-menu/models/smz-menu-item';
+import { Observable } from 'rxjs';
+import { SmzTimelineMarkerBuilder, SmzTimelineViewBuilder } from './template-builder';
+import { SmzTimelineState } from '../../modules/smz-timeline/models/smz-timeline-state';
+import { SmzCardsTemplateBuilder } from '../smz-cards/template-builder';
+import { SmzTimelineSourcesBuilder } from './source-builder';
+import { SmzTimelineMenuBuilder } from './menu-builder';
+export declare class SmzTimelineBuilder<T> {
+    _state: SmzTimelineState<T>;
+    constructor(uiDefinitionName?: string);
+    setSource(items$: Observable<T[]>): SmzTimelineBuilder<T>;
+    sources(): SmzTimelineSourcesBuilder<T>;
+    setTitle(title: string): SmzTimelineBuilder<T>;
+    template(): SmzCardsTemplateBuilder<T, SmzTimelineBuilder<T>>;
+    view(): SmzTimelineViewBuilder;
+    marker(): SmzTimelineMarkerBuilder;
+    setDynamicTitle(callback: () => string): SmzTimelineBuilder<T>;
+    setLocale(language: 'pt-BR' | 'en-US'): SmzTimelineBuilder<T>;
+    setEmptyMessage(message: string): SmzTimelineBuilder<T>;
+    buttons(items?: SmzMenuItem[]): SmzTimelineMenuBuilder;
+    menu(items?: SmzMenuItem[]): SmzTimelineMenuBuilder;
+    debugMode(): SmzTimelineBuilder<T>;
+    build(): SmzTimelineState<T>;
+}

package/lib/builders/smz-timeline/template-builder.d.ts

@@ -0,0 +1,26 @@
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzTimelineBuilder } from './state-builder';
+import { SmzTimelineMarker, SmzTimelineView } from '../../modules/smz-timeline/models/smz-timeline-state';
+export declare class SmzTimelineViewBuilder extends SmzBuilderUtilities<SmzTimelineViewBuilder> {
+    private _builder;
+    private _viewData;
+    private _layout;
+    protected that: this;
+    private _styles;
+    constructor(_builder: SmzTimelineBuilder<any>, _viewData: SmzTimelineView, _layout: 'vertical' | 'horizontal');
+    setLayout(layout: 'vertical' | 'horizontal'): SmzTimelineViewBuilder;
+    styleEvent(styleClass: string): SmzTimelineViewBuilder;
+    styleTimeline(styleClass: string): SmzTimelineViewBuilder;
+    addGap(gap?: 2 | 4 | 6 | 8 | 10 | 12): SmzTimelineViewBuilder;
+    setAlign(align: 'left' | 'right' | 'top' | 'botttom' | 'alternate'): SmzTimelineViewBuilder;
+    get timeline(): SmzTimelineBuilder<any>;
+}
+export declare class SmzTimelineMarkerBuilder extends SmzBuilderUtilities<SmzTimelineMarkerBuilder> {
+    private _builder;
+    private _markerData;
+    protected that: this;
+    constructor(_builder: SmzTimelineBuilder<any>, _markerData: SmzTimelineMarker);
+    style(styleClass: string): SmzTimelineMarkerBuilder;
+    setIcon(icon: string): SmzTimelineMarkerBuilder;
+    get timeline(): SmzTimelineBuilder<any>;
+}

package/lib/builders/smz-tree-with-details/state-builder.d.ts

@@ -0,0 +1,19 @@
+import { SmzTreeWithDetailsState } from '../../modules/smz-tree-with-details/models/tree-with-details-state';
+import { SmzTreeState } from '../../modules/smz-trees/models/tree-state';
+import { TreeNode } from 'primeng/api';
+import { Observable } from 'rxjs';
+export declare class SmzTreeWithDetailsBuilder {
+    _state: SmzTreeWithDetailsState;
+    constructor();
+    setTree(treeState: SmzTreeState): SmzTreeWithDetailsBuilder;
+    setSource(items$: Observable<any>): SmzTreeWithDetailsBuilder;
+    addSelectableTypes(...types: string[]): SmzTreeWithDetailsBuilder;
+    allowAllNodesToBeClicked(): SmzTreeWithDetailsBuilder;
+    setSelectedNode(node: TreeNode): SmzTreeWithDetailsBuilder;
+    overrideTreeContainerStyles(styleClass: string): SmzTreeWithDetailsBuilder;
+    overridePageContainerStyles(styleClass: string): SmzTreeWithDetailsBuilder;
+    overrideDetailsContainerStyles(styleClass: string): SmzTreeWithDetailsBuilder;
+    setLocale(language: 'pt-BR' | 'en-US'): SmzTreeWithDetailsBuilder;
+    debugMode(): SmzTreeWithDetailsBuilder;
+    build(): SmzTreeWithDetailsState;
+}

package/lib/builders/smz-trees/data-source-tree-builder.d.ts

@@ -0,0 +1,17 @@
+import { TreeNode } from 'primeng/api';
+import { SmzTreeGroup, SmzTreeSourceTransform } from '../../modules/smz-trees/models/tree-state';
+import { SmzNestedDataSourceTreeBuilder } from './nested-data-source-tree-builder';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzPropertyBasedDataSourceTreeBuilder } from './property-based-data-source-tree-builder';
+export declare class SmzDataSourceTreeBuilder<TBuilder> extends SmzBuilderUtilities<SmzDataSourceTreeBuilder<TBuilder>> {
+    private _builder;
+    private _content;
+    protected that: this;
+    constructor(_builder: TBuilder, _content: SmzTreeSourceTransform);
+    grouping(data: SmzTreeGroup): SmzDataSourceTreeBuilder<TBuilder>;
+    flat(keyPropertyValue: string, labelProperty: string, overrides?: Partial<TreeNode<any>>): SmzDataSourceTreeBuilder<TBuilder>;
+    flatWithRoot(rootName: string, keyPropertyValue: string, labelProperty: string, rootOverrides?: Partial<TreeNode<any>>, itemOverrides?: Partial<TreeNode<any>>): SmzDataSourceTreeBuilder<TBuilder>;
+    nested(type: string): SmzNestedDataSourceTreeBuilder<TBuilder>;
+    propertyBased(): SmzPropertyBasedDataSourceTreeBuilder<TBuilder>;
+    get tree(): TBuilder;
+}

package/lib/builders/smz-trees/nested-data-source-tree-builder.d.ts

@@ -0,0 +1,47 @@
+import { SmzTreeNestedData, SmzTreeSourceTransform } from '../../modules/smz-trees/models/tree-state';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzDataSourceTreeBuilder } from './data-source-tree-builder';
+export declare class SmzNestedDataSourceTreeBuilder<TBuilder> extends SmzBuilderUtilities<SmzNestedDataSourceTreeBuilder<TBuilder>> {
+    private _content;
+    private _dataSourceBuilder;
+    protected that: this;
+    private _nestedConfig;
+    constructor(_content: SmzTreeSourceTransform, _dataSourceBuilder: SmzDataSourceTreeBuilder<TBuilder>, type: string);
+    addChild(key: string): SmzNestedChildTreeBuilder<SmzNestedDataSourceTreeBuilder<TBuilder>>;
+    makeAsGroup(label: string): SmzNestedGroupTreeBuilder<SmzNestedDataSourceTreeBuilder<TBuilder>>;
+    setIcon(icon: string): SmzNestedDataSourceTreeBuilder<TBuilder>;
+    setType(type: string): SmzNestedDataSourceTreeBuilder<TBuilder>;
+    setDataAsSimpleNamedEntity(): SmzNestedDataSourceTreeBuilder<TBuilder>;
+    disableSelection(): SmzNestedDataSourceTreeBuilder<TBuilder>;
+    conditionalSelection(callback: (item: any) => boolean): SmzNestedDataSourceTreeBuilder<TBuilder>;
+    get dataSource(): SmzDataSourceTreeBuilder<TBuilder>;
+}
+export declare class SmzNestedChildTreeBuilder<TBuilder> extends SmzBuilderUtilities<SmzNestedChildTreeBuilder<TBuilder>> {
+    private _builder;
+    private _nestedConfig;
+    protected that: this;
+    constructor(_builder: TBuilder, _nestedConfig: SmzTreeNestedData);
+    addChild(key: string): SmzNestedChildTreeBuilder<SmzNestedChildTreeBuilder<TBuilder>>;
+    makeAsGroup(label: string): SmzNestedGroupTreeBuilder<SmzNestedChildTreeBuilder<TBuilder>>;
+    setDataAsSimpleNamedEntity(): SmzNestedChildTreeBuilder<TBuilder>;
+    removeParentPropertiesFromData(): SmzNestedChildTreeBuilder<TBuilder>;
+    setIcon(icon: string): SmzNestedChildTreeBuilder<TBuilder>;
+    setType(type: string): SmzNestedChildTreeBuilder<TBuilder>;
+    disableSelection(): SmzNestedChildTreeBuilder<TBuilder>;
+    conditionalSelection(callback: (item: any) => boolean): SmzNestedChildTreeBuilder<TBuilder>;
+    get back(): TBuilder;
+}
+export declare class SmzNestedGroupTreeBuilder<TBuilder> extends SmzBuilderUtilities<SmzNestedGroupTreeBuilder<TBuilder>> {
+    private _builder;
+    private _nestedConfig;
+    private label;
+    protected that: this;
+    constructor(_builder: TBuilder, _nestedConfig: SmzTreeNestedData, label: string);
+    setKey(key: string): SmzNestedGroupTreeBuilder<TBuilder>;
+    setType(type: string): SmzNestedGroupTreeBuilder<TBuilder>;
+    setIcon(icon: string): SmzNestedGroupTreeBuilder<TBuilder>;
+    setDataAsSimpleNamedEntity(): SmzNestedGroupTreeBuilder<TBuilder>;
+    disableSelection(): SmzNestedGroupTreeBuilder<TBuilder>;
+    conditionalSelection(callback: (item: any) => boolean): SmzNestedGroupTreeBuilder<TBuilder>;
+    get child(): TBuilder;
+}

package/lib/builders/smz-trees/property-based-data-source-tree-builder.d.ts

@@ -0,0 +1,29 @@
+import { SmzTreeSourceTransform } from '../../modules/smz-trees/models/tree-state';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzDataSourceTreeBuilder } from './data-source-tree-builder';
+import { TreeNode } from 'primeng/api';
+export declare class SmzPropertyBasedDataSourceTreeBuilder<TBuilder> extends SmzBuilderUtilities<SmzPropertyBasedDataSourceTreeBuilder<TBuilder>> {
+    private _content;
+    private _dataSourceBuilder;
+    protected that: this;
+    private _config;
+    constructor(_content: SmzTreeSourceTransform, _dataSourceBuilder: SmzDataSourceTreeBuilder<TBuilder>);
+    addRootRelation(type: string): SmzPropertyBasedDataSourceTreeBuilder<TBuilder>;
+    setLabelProperty(property: string): SmzPropertyBasedDataSourceTreeBuilder<TBuilder>;
+    setKeyProperty(property: string): SmzPropertyBasedDataSourceTreeBuilder<TBuilder>;
+    includeData(): SmzPropertyBasedDataSourceTreeBuilder<TBuilder>;
+    addRelation(property: string, type: string): SmzPropertyBasedDataSourceTreeBuilder<TBuilder>;
+    addConditionalRootRelation<TNodeData>(getTypeCallback: (node: TNodeData) => string): SmzPropertyBasedDataSourceTreeBuilder<TBuilder>;
+    addConditionalRelation<TNodeData>(property: string, getTypeCallback: (node: TNodeData) => string, alsoApplyToRoot?: boolean): SmzPropertyBasedDataSourceTreeBuilder<TBuilder>;
+    get dataSource(): SmzDataSourceTreeBuilder<TBuilder>;
+}
+export interface SmzTreePropertyBasedConfig {
+    labelProperty: string;
+    keyProperty: string;
+    includeData: boolean;
+    nodes: {
+        property: string;
+        type: string;
+        getTypeCallback: (node: TreeNode) => string;
+    }[];
+}