@zeedhi/common 1.111.1 → 3.0.0

package/dist/types/components/zd-tree/interfaces.d.ts

@@ -0,0 +1,107 @@
+import { IDatasource, IDictionary, IEventParam } from '@zeedhi/core';
+import { ITreeComponent } from '../../utils';
+import { EventDef, IComponentEvents, IComponentRender, IComponentRenderInstance } from '../zd-component/interfaces';
+import { Tree } from './tree';
+export interface ITreeNodeModel<T> {
+    title: string;
+    isLeaf?: boolean;
+    children?: ITreeNodeModel<T>[];
+    isExpanded?: boolean;
+    isSelected?: boolean;
+    isDraggable?: boolean;
+    isSelectable?: boolean;
+    data?: T;
+}
+export interface ITreeNode<T> extends ITreeNodeModel<T> {
+    isFirstChild?: boolean;
+    isLastChild?: boolean;
+    isVisible?: boolean;
+    level?: number;
+    ind?: number;
+    path?: number[];
+    pathStr?: string;
+    children?: ITreeNode<T>[];
+}
+export interface ICursorPosition<T> {
+    node: ITreeNode<T>;
+    placement: 'before' | 'inside' | 'after';
+}
+export interface ITreeSelectEvent extends IEventParam<Tree> {
+    nodes: ITreeNode<IDictionary>[];
+}
+export interface ITreeDropEvent extends IEventParam<Tree> {
+    nodes: ITreeNode<IDictionary>[];
+    position: ICursorPosition<IDictionary>;
+}
+export interface ITreeClickEvent extends IEventParam<Tree> {
+    node: ITreeNode<IDictionary>;
+}
+export interface ITreeConditionComponent extends IComponentRender {
+    conditions?: IDictionary;
+}
+export interface ITreeEvents extends IComponentEvents<any> {
+    onNodeDrop?: EventDef<ITreeDropEvent>;
+    onNodeSelect?: EventDef<ITreeSelectEvent>;
+    onNodeClick?: EventDef<ITreeClickEvent>;
+    onNodeDblClick?: EventDef<ITreeClickEvent>;
+    onNodeCheck?: EventDef<ITreeSelectEvent>;
+}
+export interface ITreeProps extends IComponentRender {
+    nodes?: ITreeNodeModel<IDictionary>[];
+    itemIconName?: string;
+    groupIconName?: string;
+    openedIconName?: string;
+    closedIconName?: string;
+    allowMultiSelect?: boolean;
+    allowDragDrop?: boolean;
+    afterTitleSlot?: ITreeConditionComponent;
+    toolbarSlot?: IComponentRender[];
+    titleSlot?: ITreeConditionComponent[];
+    events?: ITreeEvents;
+    height?: number | string;
+    maxHeight?: number | string;
+    minHeight?: number | string;
+    fillHeight?: boolean;
+    width?: number | string;
+    maxWidth?: number | string;
+    minWidth?: number | string;
+    datasource?: IDatasource;
+    parentField?: string;
+    titleField?: string;
+    dataField?: string;
+    checkedField?: string;
+    openLevelOnLoad?: number | boolean;
+    checkbox?: boolean;
+    disableCheckbox?: (args: {
+        node: ITreeNode<IDictionary>;
+        component: Tree;
+    }) => boolean;
+}
+export interface ITree extends IComponentRenderInstance, ITreeComponent {
+    nodes: ITreeNodeModel<IDictionary>[];
+    itemIconName: string;
+    groupIconName: string;
+    openedIconName: string;
+    closedIconName: string;
+    allowMultiSelect: boolean;
+    allowDragDrop: boolean;
+    afterTitleSlot?: ITreeConditionComponent;
+    toolbarSlot: IComponentRender[];
+    titleSlot: ITreeConditionComponent[];
+    events: ITreeEvents;
+    height: number | string;
+    maxHeight: number | string;
+    minHeight: number | string;
+    fillHeight: boolean;
+    width: number | string;
+    maxWidth: number | string;
+    minWidth: number | string;
+    titleField: string;
+    dataField: string;
+    checkedField: string;
+    checkbox: boolean;
+    disableCheckbox?: (args: {
+        node: ITreeNode<IDictionary>;
+        component: Tree;
+    }) => boolean;
+}

package/dist/types/components/zd-tree/tree.d.ts

@@ -0,0 +1,161 @@
+import { Datasource, Event, IDictionary, IEvents } from '@zeedhi/core';
+import { ComponentRender } from '../zd-component/component-render';
+import { IComponent, IComponentRender, IComponentRenderInstance } from '../zd-component/interfaces';
+import { ICursorPosition, ITree, ITreeConditionComponent, ITreeNode, ITreeNodeModel, ITreeProps } from './interfaces';
+export declare class Tree extends ComponentRender implements ITree {
+    /** Tree nodes */
+    nodesValue: ITreeNodeModel<IDictionary>[];
+    /** Tree Item icon name */
+    itemIconName: string;
+    /** Tree Group icon name */
+    groupIconName: string;
+    /** Tree opened group icon name */
+    openedIconName: string;
+    /** Tree closed group icon name */
+    closedIconName: string;
+    /** Allow selecting multiple nodes */
+    allowMultiSelect: boolean;
+    /** Allow dragging nodes */
+    allowDragDrop: boolean;
+    /** Render a component in front of the node title */
+    afterTitleSlot?: ITreeConditionComponent;
+    /**
+     * Components that will be rendered on toolbar slot
+     */
+    toolbarSlot: IComponentRender[];
+    /**
+     * Defines the component height. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    height: string | number;
+    /**
+     * Defines the component min height. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    minHeight: string | number;
+    /**
+     * Defines the component max height. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    maxHeight: string | number;
+    /**
+     * Set component height to fill all space available
+     */
+    fillHeight: boolean;
+    /**
+     * Defines the component width. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    width: string | number;
+    /**
+     * Defines the component min width. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    minWidth: string | number;
+    /**
+     * Defines the component max height. Possible values for this property can be
+     * <samp>'auto', '100%', '400px' or 400</samp>
+     */
+    maxWidth: string | number;
+    /**
+     * Components that will be rendered on title slot
+     */
+    titleSlot: ITreeConditionComponent[];
+    /** Datasource object */
+    datasource: Datasource;
+    /** Datasource parent field */
+    parentField: string;
+    /** Datasource title field */
+    titleField: string;
+    /** Datasource data field */
+    dataField: string;
+    /** Datasource checked field */
+    checkedField: string;
+    /**
+     * Defines if the tree will be opened or not (true/false) or if it should open only until a specific level
+     */
+    openLevelOnLoad: number | boolean;
+    /**
+     * Allow row check
+     */
+    checkbox: boolean;
+    /**
+     * Function to check if node check should be disabled
+     */
+    disableCheckbox?: (args: {
+        node: ITreeNode<IDictionary>;
+        component: Tree;
+    }) => boolean;
+    /** SlVueTree component */
+    private tree;
+    /** SlVueTree component */
+    private treeDataStructure?;
+    /**
+     * Defines if should wait and not execute GET method when Datasource is created
+     */
+    private lazyLoad;
+    /**
+     * Dictionary of nodePath ponting to Dictionary of path pointing to the condition (applied) return value
+     */
+    private appliedConditions;
+    private factoredConditions;
+    /**
+     * Creates a new instance of LabelsTree
+     * @param props Image Link props
+     */
+    constructor(props: ITreeProps);
+    /**
+     * Initialize all the properties of the declared nodes (reactivity)
+     */
+    initNodes(nodes: ITreeNodeModel<IDictionary>[], override?: IDictionary): ITreeNodeModel<IDictionary>[];
+    /** Nodes */
+    get nodes(): ITreeNodeModel<IDictionary>[];
+    set nodes(value: ITreeNodeModel<IDictionary>[]);
+    onCreated(): Promise<void>;
+    getCheckedNodes(): ITreeNode<IDictionary<any>>[];
+    /** Returns the selected nodes */
+    get selectedNodes(): ITreeNode<IDictionary>[];
+    private createDataStructure;
+    /** create nodes from datasource object */
+    createNodesFromDatasource(buildTree?: boolean): void;
+    private createNodeFromRow;
+    private createChildrenNodes;
+    /** Insert nodes by the current cursor position */
+    insertNode(newNode: ITreeNodeModel<IDictionary>): void;
+    /** Import multiples nodes by the current cursor position */
+    importNodes(nodes: ITreeNodeModel<IDictionary>[]): void;
+    /** Remove selected node */
+    removeSelected(): void;
+    /** Update selected node */
+    updateNodeData(node: ITreeNode<IDictionary>, value: IDictionary): void;
+    setTree(tree: any): void;
+    /**
+     * Return plain conditions object
+     * @param conditions Conditions object
+     * @param parentPath Path to parent property
+     */
+    protected getPlainConditions(conditions: IDictionary<any>, parentPath?: string): IDictionary<string>;
+    protected createConditions(children: ITreeConditionComponent[], parentPath?: string): void;
+    protected applyCondition(node: ITreeNode<any>, factoredConditions: IEvents<ITreeNode<IDictionary>>): IDictionary<any>;
+    protected applyChildCondition(node: ITreeNode<any>, factoredConditions?: IDictionary<IEvents<ITreeNode<IDictionary<any>>>>): IDictionary<any>;
+    reapplyConditions(node: ITreeNode<any>): IDictionary;
+    private filterObject;
+    private deleteAccessorProps;
+    protected updateActionInstance(instanceName: string, newComponent: IComponent): ComponentRender<IComponentRender>;
+    getSlotComponent(slot: IComponentRender | IComponentRender[], node: ITreeNode<IDictionary>, parentPath?: string): (IComponentRender | IComponentRenderInstance)[];
+    /** Triggers when dragging nodes have been dropped */
+    nodeDrop(nodes: ITreeNode<IDictionary>[], position: ICursorPosition<IDictionary>, event?: Event, element?: any): void;
+    /** Triggers when a node has been selected/deselected */
+    nodeSelect(nodes: ITreeNode<IDictionary>[], event?: Event, element?: any): void;
+    /** Handle click event on node */
+    nodeClick(node: ITreeNode<IDictionary>, event?: Event, element?: any): void;
+    /** Handle dblclick event on node */
+    nodeDblClick(node: ITreeNode<IDictionary>, event?: Event, element?: any): void;
+    /** Triggers when a node has been checked/unchecked */
+    nodeCheck(node: ITreeNode<IDictionary>, event?: Event, element?: HTMLElement): void;
+    clearSelection(nodes?: ITreeNodeModel<IDictionary<any>>[]): void;
+    getNode(path: number[]): ITreeNodeModel<IDictionary<any>> | undefined;
+    getParentNode(node: ITreeNode<IDictionary>): any;
+    private searchPath;
+    callDisableCheckbox(node: ITreeNode<IDictionary>): boolean;
+}

package/dist/types/components/zd-tree-grid/index.d.ts

@@ -0,0 +1,6 @@
+export * from './interfaces';
+export * from './iterable-tree';
+export * from './keymap-tree';
+export * from './tree-data-selector';
+export * from './tree-grid';
+export * from './tree-data-navigator';

package/dist/types/components/zd-tree-grid/interfaces.d.ts

@@ -0,0 +1,35 @@
+import { IDictionary } from '@zeedhi/core';
+import { ITreeComponent, ITreeDataStructure } from '../../utils/tree-data-structure/interfaces';
+import { IDataSelector, IGrid, IGridProps } from '../zd-grid';
+export interface ITreeDataSelector extends IDataSelector {
+    selectChildren(row: IDictionary<any>): void;
+    unselectChildren(row: IDictionary<any>): void;
+}
+export interface IIterableTree {
+    onMounted(element: HTMLElement): void;
+    buildTree(doGet?: boolean): void;
+    setViewUpdateScrollData(fn: () => void): void;
+    updateScrollData(): void;
+}
+export interface ITreeGridProps extends IGridProps {
+    parentField?: string;
+    openLevelOnLoad?: number | boolean;
+    fetchOnDemand?: boolean;
+    fieldHasChild?: string;
+    flat?: boolean;
+    detach?: boolean;
+    lazyLoad?: boolean;
+}
+export interface ITreeGrid extends ITreeComponent, IGrid, ITreeDataSelector, IIterableTree {
+    flat: boolean;
+    lazyLoad: boolean;
+    treeDataStructure: ITreeDataStructure;
+    getChildren(row: IDictionary): IDictionary[];
+    findDataIndex(data: IDictionary<any>[], value: any): number;
+    getParentRow(row: IDictionary): IDictionary;
+    buildTreeStructure(): void;
+    resetTree(): void;
+    filterRootData(): Promise<any>;
+    navigateToggle(collapse: boolean): void;
+    toggleExpand(row: IDictionary<any>, rowIndex?: number): Promise<IDictionary<any>[] | undefined>;
+}

package/dist/types/components/zd-tree-grid/iterable-tree.d.ts

@@ -0,0 +1,10 @@
+import { IIterableTree, ITreeGrid } from './interfaces';
+export declare class IterableTree implements IIterableTree {
+    private treeGrid;
+    viewUpdateScrollData?: () => void;
+    constructor(treeGrid: ITreeGrid);
+    onMounted(): void;
+    buildTree(doGet?: boolean): void;
+    setViewUpdateScrollData(fn: () => void): void;
+    updateScrollData(): void;
+}

package/dist/types/components/zd-tree-grid/keymap-tree.d.ts

@@ -0,0 +1,7 @@
+import { IKeyMap } from '@zeedhi/core';
+import { Component } from '../zd-component/component';
+import { IKeyMapConfig } from '../zd-grid';
+import { ITreeGrid } from './interfaces';
+export declare class KeyMapTree implements IKeyMapConfig<ITreeGrid> {
+    getMap(instance: Component & ITreeGrid): IKeyMap;
+}

package/dist/types/components/zd-tree-grid/tree-data-navigator.d.ts

@@ -0,0 +1,10 @@
+import { IDataNavigator, VerticalDirection } from '../zd-grid';
+import { ITreeGrid } from './interfaces';
+export declare class TreeDataNavigator implements IDataNavigator {
+    private treeGrid;
+    private dataNavigator;
+    constructor(treeGrid: ITreeGrid);
+    navigateDatasource(direction: VerticalDirection): void;
+    navigatePageUp(): void;
+    navigatePageDown(): void;
+}

package/dist/types/components/zd-tree-grid/tree-data-selector.d.ts

@@ -0,0 +1,18 @@
+import { IDictionary } from '@zeedhi/core';
+import { ITreeDataSelector, ITreeGrid } from './interfaces';
+export declare class TreeDataSelector implements ITreeDataSelector {
+    private treeGrid;
+    private dataSelector;
+    constructor(treeGrid: ITreeGrid);
+    private removeDuplicates;
+    selectChildren(row: IDictionary<any>): void;
+    unselectChildren(row: IDictionary<any>): void;
+    private selectParents;
+    private unselectParents;
+    selectRow(row: IDictionary<any>, select: boolean): void;
+    selectAll(isSelected: boolean): void;
+    toggleRow(row: IDictionary): void;
+    callDisableSelection(row: IDictionary): boolean;
+    selectClick(row: IDictionary<any>, isSelected: boolean, event: Event, element?: HTMLElement): void;
+    selectAllClick(isSelected: boolean, event: Event, element?: HTMLElement): void;
+}

package/dist/types/components/zd-tree-grid/tree-grid.d.ts

@@ -0,0 +1,119 @@
+import { IDictionary, IEventParam } from '@zeedhi/core';
+import { IIterableProps } from '..';
+import { ITreeDataStructure } from '../../utils';
+import { IComponent, IComponentRender } from '../zd-component/interfaces';
+import { Direction, GridColumn, IGrid, IGridColumn, VerticalDirection } from '../zd-grid';
+import { Iterable } from '../zd-iterable/iterable';
+import { ITreeGrid, ITreeGridProps } from './interfaces';
+export declare class TreeGrid extends Iterable<GridColumn> implements ITreeGrid {
+    private tableActionBuilder;
+    private iterableTable;
+    private dataSelector;
+    private gridEvents;
+    private dataNavigator;
+    private viewNavigator;
+    private keyMapMerger;
+    private iterableTree;
+    treeDataStructure: ITreeDataStructure;
+    currentColumn: GridColumn | null;
+    selectedRows: IDictionary<any>[];
+    selectionState: {
+        allSelected: boolean;
+        except: IDictionary<any>[];
+    };
+    rowStyleConditions?: (row: IDictionary) => IDictionary;
+    selectAllPages: boolean;
+    selectable: boolean;
+    disableSelection?: (args: {
+        row: IDictionary<any>;
+        component: IGrid;
+    }) => boolean;
+    cellSelection: boolean;
+    toolbarSlot: IComponentRender[];
+    footerSlot: IComponentRender[];
+    noResultsText: string;
+    noResultSlot: IComponentRender[];
+    errorSlot: IComponentRender[];
+    dense: boolean;
+    dragColumns: boolean;
+    headerBackground: string;
+    headerCellTextColor: string;
+    height: string | number;
+    loadingText: string;
+    maxHeight: string | number;
+    maxWidth: string | number;
+    minHeight: string | number;
+    minWidth: string | number;
+    noDataText: string;
+    noDataSlot: IComponentRender[];
+    resizeColumns: boolean;
+    showFooter: boolean;
+    showHeader: boolean;
+    showSelectAll: boolean;
+    width: string | number;
+    backgroundColor: string;
+    parentField: string;
+    openLevelOnLoad: number | boolean;
+    fetchOnDemand: boolean;
+    fieldHasChild?: string;
+    flat: boolean;
+    detach: boolean;
+    lazyLoad: boolean;
+    constructor(props: ITreeGridProps);
+    protected initializeDatasource(props: IIterableProps): void;
+    onCreated(): void;
+    onMounted(element: HTMLElement): void;
+    onBeforeDestroy(): void;
+    /**
+     * toggleExpand
+     */
+    toggleExpand(row: IDictionary<any>, rowIndex?: number): Promise<IDictionary<any>[] | undefined>;
+    /**
+     * Toggle expand/collapse using navigation keys
+     * @param collapse Should collapse
+     */
+    navigateToggle(collapse: boolean): void;
+    getChildren(row: IDictionary): IDictionary[];
+    findDataIndex(data: IDictionary<any>[], value: any): number;
+    getParentRow(row: IDictionary): IDictionary;
+    buildTreeStructure(): void;
+    resetTree(): void;
+    filterRootData(): Promise<any>;
+    getConditionalProps({ row, column }: {
+        row: IDictionary;
+        column: GridColumn;
+    }): Partial<IComponentRender>;
+    navigatePageUp(): void;
+    navigatePageDown(): void;
+    setViewNavigate(viewNavigate: (direction: Direction, event?: Event) => void): void;
+    navigateLeft(params: IEventParam<any>): void;
+    navigateRight(params: IEventParam<any>): void;
+    navigateUp(): void;
+    navigateDown(): void;
+    navigateDatasource(direction: VerticalDirection): void;
+    createColumn(column: IGridColumn): GridColumn;
+    rowClick(row: IDictionary<any>, event: Event, element?: HTMLElement): void;
+    cellClick(row: IDictionary<any>, column: GridColumn, event: Event, element?: HTMLElement): void;
+    selectClick(row: IDictionary<any>, isSelected: boolean, event: Event, element?: HTMLElement): void;
+    selectAllClick(isSelected: boolean, event: Event, element?: HTMLElement): void;
+    selectAll(isSelected: boolean): void;
+    toggleRow(row: IDictionary): void;
+    selectRow(row: IDictionary, select: boolean): void;
+    callDisableSelection(row: IDictionary): boolean;
+    changeOrder(sortBy: {
+        key: string;
+        order: 'asc' | 'desc';
+    }[]): Promise<void>;
+    selectCell(row: IDictionary, column: GridColumn): void;
+    reapplyRowStyleConditions(row: IDictionary): IDictionary;
+    getRowStyleConditions(row: IDictionary): IDictionary;
+    deleteRows(): Promise<any[]>;
+    getActionComponent(actionComponent: IComponent, column: GridColumn, row: IDictionary, parentPath?: string): IComponent;
+    changeData(data?: IDictionary<any>[]): void;
+    selectChildren(row: IDictionary<any>): void;
+    unselectChildren(row: IDictionary<any>): void;
+    buildTree(doGet?: boolean): void;
+    setViewUpdateScrollData(fn: () => void): void;
+    updateScrollData(): void;
+    updateData(data: IDictionary[]): Promise<any>;
+}

package/dist/types/error/delete-rows.d.ts

@@ -0,0 +1,7 @@
+import { ZeedhiCommonError } from './zeedhi-error';
+/**
+ * Delete rows error
+ */
+export declare class DeleteRowsError extends ZeedhiCommonError {
+    constructor();
+}

package/dist/types/error/index.d.ts

@@ -0,0 +1,2 @@
+export * from './zeedhi-error';
+export * from './delete-rows';

package/dist/types/error/non-initialized.d.ts

@@ -0,0 +1,7 @@
+import { ZeedhiCommonError } from './zeedhi-error';
+/**
+ * NonInitialized error
+ */
+export declare class NonInitializedError extends ZeedhiCommonError {
+    constructor(className: string);
+}

package/dist/types/error/tek-grid-delete-rows.d.ts

@@ -0,0 +1,7 @@
+import { TeknisaCommonError } from './teknisa-common-error';
+/**
+ * TekGridDelete rows error
+ */
+export declare class TekGridDeleteRowsError extends TeknisaCommonError {
+    constructor();
+}

package/dist/types/error/teknisa-common-error.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Base Teknisa error
+ */
+export declare class TeknisaCommonError extends Error {
+    constructor(message: string);
+}

package/dist/types/error/zeedhi-error.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Base Zeedhi error
+ */
+export declare class ZeedhiCommonError extends Error {
+    constructor(message: string);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+declare const AutoNumeric: any;
+export * from './components';
+export * from './services';
+export * from './utils';
+export { AutoNumeric };

package/dist/types/services/index.d.ts

@@ -0,0 +1,4 @@
+export * from './zd-alert';
+export * from './zd-loading/loading-service';
+export * from './zd-dialog/dialog-service';
+export * from './zd-modal/modal-service';

package/dist/types/services/zd-alert/alert-queue.d.ts

@@ -0,0 +1,13 @@
+import { Alert, IAlert } from '../../components';
+import { IAlertsManager } from './interfaces';
+export declare class AlertQueue implements IAlertsManager {
+    protected queue: IAlert[];
+    visibleInstances: Alert[];
+    show(alert: IAlert): number;
+    /**
+     * Displays an alert
+     * @param alert Alert Structure
+     */
+    protected display(alert: IAlert): number;
+    remove(index: number): void;
+}

package/dist/types/services/zd-alert/alert-replace.d.ts

@@ -0,0 +1,18 @@
+import { Alert, IAlert } from '../../components';
+import { IAlertsManager } from './interfaces';
+/**
+ * Displays alerts using replace.
+ * Only one alert can be visible at a time, and when a new alert is shown,
+ * the previous one is instantly removed
+ */
+export declare class AlertReplace implements IAlertsManager {
+    protected queue: IAlert[];
+    visibleInstances: Alert[];
+    show(alert: IAlert): number;
+    /**
+     * Displays an alert
+     * @param alert Alert Structure
+     */
+    protected display(alert: IAlert): number;
+    remove(index: number): void;
+}

package/dist/types/services/zd-alert/alert-service.d.ts

@@ -0,0 +1,45 @@
+import { IAlert } from '../../components/zd-alert/interfaces';
+import { AlertQueue } from './alert-queue';
+import { AlertReplace } from './alert-replace';
+import { AlertStack } from './alert-stack';
+import { IAlertsManager } from './interfaces';
+export type Multiple = 'replace' | 'queue' | 'stack';
+/**
+ * Alert Service Class
+ */
+export declare class AlertService {
+    /**
+     * TODO: conferir se o alertsManager será necessário após a atualização 3.6.0 do vuetify,
+     * que vai implementar a funcionalidade internamente
+     * https://github.com/vuetifyjs/vuetify/milestone/72
+     * https://github.com/vuetifyjs/vuetify/issues/2384
+     */
+    static alertsManager: IAlertsManager;
+    static instantiateManager(multiple: Multiple): AlertQueue | AlertStack | AlertReplace;
+    static registerManager(instance: IAlertsManager): void;
+    /**
+     * Displays an alert.
+     * If has an opened alert it will be closed.
+     * @param alert Alert structure
+     * @returns Alert id
+     */
+    static show(alert: IAlert): number;
+    /**
+     * Hides alert by index. Default index is 0
+     */
+    static hide(index?: number): void;
+    /**
+     * Hides alert by alert id (returned by the `show` method)
+     * @param id
+     */
+    static hideById(id: number): void;
+    /**
+     * Hides all of the alerts
+     */
+    static hideAll(): void;
+    /**
+     * Removes an alert from the alert queue
+     * @param index index of the alert to be removed
+     */
+    static remove(index: number): void;
+}

package/dist/types/services/zd-alert/alert-stack.d.ts

@@ -0,0 +1,9 @@
+import { Alert, IAlert } from '../../components';
+import { IAlertsManager } from './interfaces';
+export declare class AlertStack implements IAlertsManager {
+    protected queue: IAlert[];
+    visibleInstances: Alert[];
+    show(alert: IAlert): number;
+    private display;
+    remove(index: number): void;
+}

package/dist/types/services/zd-alert/index.d.ts

@@ -0,0 +1,5 @@
+export * from './alert-queue';
+export * from './alert-stack';
+export * from './alert-replace';
+export * from './alert-service';
+export * from './interfaces';

package/dist/types/services/zd-alert/interfaces.d.ts

@@ -0,0 +1,6 @@
+import { Alert, IAlert } from '../../components';
+export interface IAlertsManager {
+    visibleInstances: Alert[];
+    show(alert: IAlert): number;
+    remove(index: number): void;
+}

package/dist/types/services/zd-dialog/dialog-service.d.ts

@@ -0,0 +1,24 @@
+import { Dialog } from '../../components/zd-dialog/dialog';
+import { IDialog } from '../../components/zd-dialog/interfaces';
+/**
+ * Dialog Service Class
+ */
+export declare class DialogService {
+    static instance: Dialog;
+    /**
+     * Displays a dialog.
+     * If has an opened dialog it will be closed.
+     * @param dialog dialog structure
+     */
+    static show(dialog: IDialog): void;
+    /**
+     * Hides current dialog
+     */
+    static hide(): void;
+    /**
+     * Displays a dialog
+     * @param dialog Dialog structure
+     * @private
+     */
+    private static display;
+}