@ngx-smz/core 19.2.0

package/lib/modules/smz-trees/models/tree-state.d.ts

@@ -0,0 +1,163 @@
+import { TreeNode } from 'primeng/api';
+import { SmzTreeMenuItem } from './tree-menu-item';
+import { SmzTreeToolbarButton } from './tree-toolbar-button';
+import { SmzTreeNode } from './tree-node';
+import { SmzTreeDynamicMenuBuilder } from '../../../builders/smz-trees/tree-builder';
+export interface SmzTreeState {
+    isDebug?: boolean;
+    header?: {
+        isVisible?: boolean;
+        title?: string;
+        toolbar?: {
+            isVisible?: boolean;
+            alignment?: 'start' | 'end';
+            source?: 'state' | 'template';
+            buttonType?: 'rounded-outlined' | 'rounded-filled' | 'rounded-borderless' | 'square-outlined' | 'square-filled' | 'square-borderless';
+            treeExpandButtons?: {
+                isVisible?: boolean;
+                expandLabel?: string;
+                collapseLabel?: string;
+            };
+            nodeExpandButtons?: {
+                isVisible?: boolean;
+                expandLabel?: string;
+                collapseLabel?: string;
+                expandTooltip?: string;
+                collapseTooltip?: string;
+                disabledTooltip?: string;
+            };
+            items?: SmzTreeToolbarButton[];
+        };
+    };
+    footer?: {
+        isVisible?: boolean;
+    };
+    menu?: {
+        /**
+         * Controls the visibility of the button menu of the rows
+         */
+        isVisible: boolean;
+        /**
+         * Controls the behavior of the menu
+         */
+        behavior: 'context-menu' | 'row-menu';
+        /**
+         * Controls the types that the menu will be shown
+         * When using Dynamic Items, this property needs to be set manually
+         */
+        uniqueTypes: string[];
+        /**
+         * Controls the icon of the row menu
+         */
+        rowMenuIcon?: string;
+        /**
+         * Controls the severity of the row menu icon
+         */
+        rowMenuIconSeverity?: 'primary' | 'secondary' | 'success' | 'info' | 'contrast' | 'help' | 'danger';
+        /**
+         * Items for the popup menu
+         */
+        items: SmzTreeMenuItem[];
+        /**
+         * Gets the dynamic items for the row menu
+         */
+        getDynamicItems: (_: SmzTreeDynamicMenuBuilder, node: SmzTreeNode<unknown>) => SmzTreeMenuItem[];
+    };
+    /**
+     * Behavior of the empty feedback
+     */
+    emptyFeedback?: {
+        /**
+         * Message displayed when the table has no data
+         */
+        message?: string;
+        /**
+         * Extra information to be shown below the main message
+         */
+        extraInfo?: string;
+        /**
+         * Controls the behavior the opnional action button. If nothing
+         * is specified, no button is shown
+         */
+        actionButton?: {
+            /**
+             * Button label
+             */
+            label?: string;
+            /**
+             * Callback to be executed on the button is clicked
+             */
+            callback?: (event?: MouseEvent) => void;
+        };
+        image?: string;
+        isFeatured: boolean;
+    };
+    selection?: {
+        mode?: 'single' | 'multiple' | 'checkbox';
+        propagateUp?: boolean;
+        propagateDown?: boolean;
+        expandNodes?: boolean;
+    };
+    loading?: {
+        isLoading?: boolean;
+        icon?: string;
+    };
+    filter?: {
+        show?: boolean;
+        mode?: 'lenient' | 'strict';
+        filterBy?: string[];
+        textPlaceholder?: string;
+        styleClass: string;
+    };
+    dragAndDrop?: {
+        draggable?: boolean;
+        droppable?: boolean;
+        validateDrop?: boolean;
+        configuration?: {
+            dragType: string;
+            dropType: string;
+        }[];
+    };
+    content: SmzTreeSourceTransform;
+}
+export interface SmzTreeSourceTransform {
+    sincronize: boolean;
+    dataTransform?: (items: any[]) => SmzTreeNode<any>[];
+}
+export interface SmzTreeContext {
+    state: SmzTreeState;
+}
+export interface SmzTreeGroup {
+    endNode: SmzTreeGroupNodeConfig;
+    group: SmzTreeGroupData;
+}
+export interface SmzTreeGroupNodeConfig {
+    keyPropertyValue: string;
+    labelProperty: string;
+    type: string;
+    nodeOverrides: Partial<TreeNode>;
+}
+export interface SmzTreeGroupData extends SmzTreeGroupNodeConfig {
+    keyPropertyData: string;
+    group: SmzTreeGroupData;
+}
+export interface SmzTreeNestedData {
+    key?: string;
+    labelKey: string;
+    valueKey: string;
+    type: string;
+    nodeOverridesConfig: SmzTreeOverridesConfig;
+    group: {
+        makeChildrenAsGroup: boolean;
+        label: string;
+        key: string;
+        type: string;
+        nodeOverridesConfig: SmzTreeOverridesConfig;
+    };
+    dataType: 'simpleNamedEntity' | 'same' | 'clean';
+    children?: SmzTreeNestedData[];
+}
+export interface SmzTreeOverridesConfig {
+    nodeOverrides: Partial<TreeNode>;
+    conditionalSelection: (item: any) => boolean;
+}

package/lib/modules/smz-trees/models/tree-toolbar-button.d.ts

@@ -0,0 +1,8 @@
+import { SmzTreeNode } from './tree-node';
+export interface SmzTreeToolbarButton {
+    label?: string;
+    icon?: string;
+    callback?: (event: MouseEvent, tree: SmzTreeNode[], nodes?: SmzTreeNode[]) => void;
+    color?: 'secondary' | 'success' | 'info' | 'warning' | 'help' | 'danger';
+    tooltip?: string;
+}

package/lib/modules/smz-trees/ngx-smz-trees.module.d.ts

@@ -0,0 +1,24 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./features/tree/tree.component";
+import * as i2 from "./pipes/data-transform-tree.pipe";
+import * as i3 from "@angular/common";
+import * as i4 from "primeng/api";
+import * as i5 from "primeng/table";
+import * as i6 from "primeng/button";
+import * as i7 from "@angular/forms";
+import * as i8 from "../../common/stop-click-propagation/click-stop-propagation.module";
+import * as i9 from "../smz-data-info/smz-data-info.module";
+import * as i10 from "primeng/tooltip";
+import * as i11 from "primeng/contextmenu";
+import * as i12 from "primeng/tree";
+import * as i13 from "primeng/inputtext";
+import * as i14 from "primeng/skeleton";
+import * as i15 from "../smz-menu/smz-menu.module";
+import * as i16 from "primeng/menu";
+import * as i17 from "primeng/iconfield";
+import * as i18 from "primeng/inputicon";
+export declare class NgxSmzTreesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxSmzTreesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxSmzTreesModule, [typeof i1.SmzTreeComponent, typeof i2.SmzDataTransformTreePipe], [typeof i3.CommonModule, typeof i4.SharedModule, typeof i5.TableModule, typeof i6.ButtonModule, typeof i7.FormsModule, typeof i8.ClickStopPropagationModule, typeof i9.NgxSmzDataInfoModule, typeof i10.TooltipModule, typeof i11.ContextMenuModule, typeof i12.TreeModule, typeof i10.TooltipModule, typeof i13.InputTextModule, typeof i14.SkeletonModule, typeof i15.NgxSmzMenuModule, typeof i16.MenuModule, typeof i17.IconFieldModule, typeof i18.InputIconModule], [typeof i1.SmzTreeComponent, typeof i4.SharedModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxSmzTreesModule>;
+}

package/lib/modules/smz-trees/pipes/data-transform-tree.pipe.d.ts

@@ -0,0 +1,12 @@
+import { PipeTransform } from '@angular/core';
+import { SmzTreeSourceTransform } from '../models/tree-state';
+import { TreeHelperService } from '../services/tree-helper.service';
+import * as i0 from "@angular/core";
+export declare class SmzDataTransformTreePipe implements PipeTransform {
+    private treeHelper;
+    constructor(treeHelper: TreeHelperService);
+    transform(items: any[], isDebug: boolean, content: SmzTreeSourceTransform, key: string, that: any): any[];
+    private response;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmzDataTransformTreePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<SmzDataTransformTreePipe, "dataTransformTree", false>;
+}

package/lib/modules/smz-trees/public-api.d.ts

@@ -0,0 +1,9 @@
+export * from './ngx-smz-trees.module';
+export * from './features/tree/tree.component';
+export * from './models/tree-state';
+export * from './models/tree-menu-item';
+export * from './models/drag-and-drop';
+export * from './models/tree-node';
+export * from './services/tree-helper.service';
+export * from './utils/tree-helpers';
+export * from './pipes/data-transform-tree.pipe';

package/lib/modules/smz-trees/services/tree-helper.service.d.ts

@@ -0,0 +1,18 @@
+import { Actions, Store } from '@ngxs/store';
+import { SmzTreeNode } from '../models/tree-node';
+import * as i0 from "@angular/core";
+export declare class TreeHelperService {
+    private actions$;
+    private store;
+    trees: {
+        [key: string]: SmzTreeNode[];
+    };
+    constructor(actions$: Actions, store: Store);
+    private add;
+    clear(key: string): void;
+    sincronize(key: string, result: SmzTreeNode[]): SmzTreeNode[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeHelperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TreeHelperService>;
+}
+export declare function synchronizeTrees(destinationTree: SmzTreeNode[], sourceTree: SmzTreeNode[]): void;
+export declare function synchronizeNodes(destinationNode: SmzTreeNode, sourceNode: SmzTreeNode): void;

package/lib/modules/smz-trees/utils/tree-helpers.d.ts

@@ -0,0 +1,8 @@
+import { TreeNode } from 'primeng/api';
+export declare namespace TreeHelpers {
+    function synchronizeTrees(destinationTrees: TreeNode[], sourceTrees: TreeNode[]): void;
+    function findTreeNodeByKey<T>(nodes: TreeNode<T>[] | undefined, key: string): TreeNode<T> | null;
+    function findTreeNodeDataByKey<T>(nodes: TreeNode<T>[] | undefined, key: string): T | null;
+    function findTreeNodesByKeys<T>(nodes: TreeNode<T>[] | undefined, keys: string[]): TreeNode<T>[];
+    function findTreeNodesDataByKeys<T>(nodes: TreeNode<T>[] | undefined, keys: string[]): T[];
+}

package/lib/modules/smz-ui-block/public-api.d.ts

@@ -0,0 +1,4 @@
+export * from './smz-ui-block.module';
+export * from './smz-ui-block.component';
+export * from './smz-ui-block.directive';
+export * from './smz-ui-block.service';

package/lib/modules/smz-ui-block/smz-ui-block.component.d.ts

@@ -0,0 +1,16 @@
+import { ChangeDetectorRef, OnInit } from '@angular/core';
+import { SmzUiBlockService } from './smz-ui-block.service';
+import * as i0 from "@angular/core";
+export interface SmzUiBlockConfig {
+    key: string;
+    component: any;
+    blocked: boolean;
+}
+export declare class SmzUiBlockComponent implements OnInit {
+    service: SmzUiBlockService;
+    private cdf;
+    constructor(service: SmzUiBlockService, cdf: ChangeDetectorRef);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmzUiBlockComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SmzUiBlockComponent, "smz-ui-block", never, {}, {}, never, never, false, never>;
+}

package/lib/modules/smz-ui-block/smz-ui-block.directive.d.ts

@@ -0,0 +1,15 @@
+import { ElementRef, OnInit, OnDestroy, ChangeDetectorRef } from '@angular/core';
+import { SmzUiBlockService } from './smz-ui-block.service';
+import * as i0 from "@angular/core";
+export declare class SmzUiBlockDirective implements OnInit, OnDestroy {
+    el: ElementRef;
+    private service;
+    private cdr;
+    key: string;
+    component: any;
+    constructor(el: ElementRef, service: SmzUiBlockService, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmzUiBlockDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SmzUiBlockDirective, "[smzUiBlock]", never, { "component": { "alias": "component"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/modules/smz-ui-block/smz-ui-block.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./smz-ui-block.component";
+import * as i2 from "./smz-ui-block.directive";
+import * as i3 from "@angular/common";
+import * as i4 from "primeng/blockui";
+export declare class NgxSmzUiBlockModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxSmzUiBlockModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxSmzUiBlockModule, [typeof i1.SmzUiBlockComponent, typeof i2.SmzUiBlockDirective], [typeof i3.CommonModule, typeof i4.BlockUIModule], [typeof i2.SmzUiBlockDirective, typeof i1.SmzUiBlockComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxSmzUiBlockModule>;
+}

package/lib/modules/smz-ui-block/smz-ui-block.service.d.ts

@@ -0,0 +1,16 @@
+import { BehaviorSubject } from 'rxjs';
+import { SmzUiBlockConfig } from './smz-ui-block.component';
+import * as i0 from "@angular/core";
+export declare class SmzUiBlockService {
+    blocks: SmzUiBlockConfig[];
+    blocked: boolean;
+    onChanges: BehaviorSubject<void>;
+    constructor();
+    add(key: string, component: any): SmzUiBlockConfig;
+    update(key: string, component: any, blocked: boolean): void;
+    remove(key: string): void;
+    blockAll(): void;
+    unBlockAll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmzUiBlockService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SmzUiBlockService>;
+}

package/lib/modules/smz-viewport/models/smz-viewport-config-direction.d.ts

@@ -0,0 +1,5 @@
+export declare const InViewportConfigDirection: {
+    readonly BOTH: "both";
+    readonly VERTICAL: "vertical";
+    readonly HORIZONTAL: "horizontal";
+};

package/lib/modules/smz-viewport/models/smz-viewport-config.d.ts

@@ -0,0 +1,19 @@
+import type { InViewportConfigCheckFn, InViewportConfigDirections, InViewportConfigOptions } from '../types';
+export declare class SmzViewportConfig {
+    _root?: Element;
+    _rootMargin: string;
+    _threshold: number | number[];
+    _partial: boolean;
+    _direction: InViewportConfigDirections;
+    _checkFn?: InViewportConfigCheckFn;
+    _hash: string;
+    private constructor();
+    static fromOptions(options?: Partial<InViewportConfigOptions>): SmzViewportConfig;
+    get root(): Element | undefined;
+    get rootMargin(): string;
+    get threshold(): number | number[];
+    get partial(): boolean;
+    get direction(): InViewportConfigDirections;
+    get hash(): string;
+    get checkFn(): InViewportConfigCheckFn | undefined;
+}

package/lib/modules/smz-viewport/public-api.d.ts

@@ -0,0 +1,3 @@
+export * from './smz-viewport.module';
+export * from './smz-viewport.service';
+export * from './smz-viewport.directive';

package/lib/modules/smz-viewport/smz-viewport.directive.d.ts

@@ -0,0 +1,23 @@
+import { AfterViewInit, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import { SmzViewportService } from './smz-viewport.service';
+import type { InViewportConfigOptions } from './types';
+import * as i0 from "@angular/core";
+export declare const InViewportMetadata: unique symbol;
+export declare class SmzViewportDirective implements AfterViewInit, OnDestroy {
+    private readonly platformId;
+    private readonly elementRef;
+    private readonly inViewport;
+    set options(value: Partial<InViewportConfigOptions>);
+    readonly inViewportAction: EventEmitter<any>;
+    private config;
+    private readonly destroyed$;
+    constructor(platformId: Object, // eslint-disable-line
+    elementRef: ElementRef, inViewport: SmzViewportService);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private check;
+    private isVisible;
+    private emitAction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmzViewportDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SmzViewportDirective, "[smzViewport]", never, { "options": { "alias": "smzViewportOptions"; "required": false; }; }, { "inViewportAction": "inViewportAction"; }, never, never, false, never>;
+}

package/lib/modules/smz-viewport/smz-viewport.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./smz-viewport.directive";
+import * as i2 from "@angular/common";
+export declare class NgxSmzViewportModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxSmzViewportModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxSmzViewportModule, [typeof i1.SmzViewportDirective], [typeof i2.CommonModule], [typeof i1.SmzViewportDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxSmzViewportModule>;
+}

package/lib/modules/smz-viewport/smz-viewport.service.d.ts

@@ -0,0 +1,18 @@
+import { NgZone } from '@angular/core';
+import { SmzViewportConfig } from './models/smz-viewport-config';
+import type { InViewportTrigger } from './types';
+import * as i0 from "@angular/core";
+export declare class SmzViewportService {
+    private ngZone;
+    get trigger$(): InViewportTrigger;
+    private readonly triggerSubject;
+    private registry;
+    constructor(ngZone: NgZone);
+    register(target: Element, config: SmzViewportConfig): void;
+    unregister(target: Element, config: SmzViewportConfig): void;
+    private emitTrigger;
+    private getRootElement;
+    private findEntry;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmzViewportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SmzViewportService>;
+}

package/lib/modules/smz-viewport/types/in-viewport-config-check-fn.d.ts

@@ -0,0 +1,6 @@
+import type { SmzViewportConfig } from '../models/smz-viewport-config';
+export interface InViewportConfigCheckFnOptions {
+    force: boolean;
+    config: SmzViewportConfig;
+}
+export type InViewportConfigCheckFn = (entry: IntersectionObserverEntry | undefined, options: InViewportConfigCheckFnOptions) => any;

package/lib/modules/smz-viewport/types/in-viewport-config-directions.d.ts

@@ -0,0 +1 @@
+export type InViewportConfigDirections = 'both' | 'vertical' | 'horizontal';

package/lib/modules/smz-viewport/types/in-viewport-config-options.d.ts

@@ -0,0 +1,10 @@
+import type { InViewportConfigCheckFn } from './in-viewport-config-check-fn';
+import type { InViewportConfigDirections } from './in-viewport-config-directions';
+export interface InViewportConfigOptions {
+    root: Element;
+    rootMargin: string;
+    threshold: number | number[];
+    partial: boolean;
+    direction: InViewportConfigDirections;
+    checkFn: InViewportConfigCheckFn;
+}

package/lib/modules/smz-viewport/types/in-viewport-registry-entry.d.ts

@@ -0,0 +1,9 @@
+import type { Observable } from 'rxjs';
+export interface InViewportRegistryEntry {
+    root: Element | null;
+    configHash: string;
+    targets: Set<Element>;
+    observer: IntersectionObserver;
+}
+export type InViewportRegistryEntries = InViewportRegistryEntry[];
+export type InViewportTrigger = Observable<IntersectionObserverEntry>;

package/lib/modules/smz-viewport/types/index.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * @license
+ * Copyright (c) 2020 Piotr Stępniewski <k3nsei.pl@gmail.com>
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file in the root directory of this source tree.
+ */
+export * from './in-viewport-config-check-fn';
+export * from './in-viewport-config-directions';
+export * from './in-viewport-config-options';
+export * from './in-viewport-registry-entry';

package/lib/modules/smz-viewport/utils/utils.d.ts

@@ -0,0 +1,17 @@
+import type { InViewportConfigCheckFn, InViewportConfigDirections } from '../types';
+export declare const isObject: (value: unknown) => value is Record<string | number | symbol, any>;
+export declare const isNotEmptyArray: <T = any>(value: unknown) => value is T[];
+export declare function isPlatformBrowser(): boolean;
+export declare function isPlatformServer(): boolean;
+export declare function toBase64Browser(input: string): string;
+export declare const toBase64Server: (input: string) => string;
+export declare const toBase64: (input: string) => string;
+export declare const stringifyObject: (input: unknown) => string;
+export declare const withRoot: (value: unknown) => Element | undefined;
+export declare const withRootMargin: (value: unknown) => string;
+export declare const isValidThreshold: (value: unknown) => value is number;
+export declare const withThreshold: (value: unknown) => number[];
+export declare const withPartial: (partial?: unknown) => boolean;
+export declare const isValidDirection: (value: unknown) => value is InViewportConfigDirections;
+export declare const withDirection: (value: unknown) => InViewportConfigDirections;
+export declare const withCheckFn: (value: unknown) => InViewportConfigCheckFn | undefined;

package/lib/ngx-smz-ui.component.d.ts

@@ -0,0 +1,8 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class NgxSmzUiComponent implements OnInit {
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxSmzUiComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxSmzUiComponent, "lib-ngx-smz-ui", never, {}, {}, never, never, false, never>;
+}

package/lib/ngx-smz-ui.config.d.ts

@@ -0,0 +1,30 @@
+import { Translation } from 'primeng/api';
+import { NgxRbkUtilsConfig } from './modules/rbk-utils/ngx-rbk-utils.config';
+import { SmzDialogsConfig } from './modules/smz-dialogs/smz-dialogs.config';
+import { SmzLayoutsConfig } from './modules/smz-layouts/core/globals/smz-layouts.config';
+import { SmzTablesConfig } from './modules/smz-tables/models/table-configs';
+export declare const SmzUiEnvironment: {
+    production: boolean;
+    serverUrl: string;
+    authenticationApi: string;
+    baseHref: string;
+};
+export declare class NgxSmzUiConfig {
+    debugMode: boolean;
+    legacyMode: boolean;
+    serverUrl: string;
+    rbkUtils: NgxRbkUtilsConfig;
+    tables: SmzTablesConfig;
+    dialogs: SmzDialogsConfig;
+    layouts: SmzLayoutsConfig;
+    locale: SmzLocaleConfig;
+}
+export interface SmzLocaleConfig {
+    code: "pt-BR" | "en-US";
+    authorization: {
+        tenant: {
+            displayName: string;
+        };
+    };
+    translation: Translation;
+}

package/lib/ngx-smz-ui.module.d.ts

@@ -0,0 +1,15 @@
+import { Injector, ModuleWithProviders } from '@angular/core';
+import { SmzUiBuilder } from './builders/smz-ui/ui-builder';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "./ngx-smz-ui.component";
+import * as i2 from "./modules/smz-dialogs/smz-dialogs.module";
+import * as i3 from "./modules/rbk-utils/ngx-rbk-utils.module";
+import * as i4 from "./modules/smz-layouts/ngx-smz-layouts.module";
+export declare class NgxSmzUiModule {
+    constructor(injector: Injector, router: Router);
+    static forRoot(builder: SmzUiBuilder): ModuleWithProviders<NgxSmzUiModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxSmzUiModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxSmzUiModule, [typeof i1.NgxSmzUiComponent], [typeof i2.NgxSmzDialogsModule, typeof i3.NgxRbkUtilsModule, typeof i4.NgxSmzLayoutsModule], [typeof i1.NgxSmzUiComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxSmzUiModule>;
+}

package/lib/standalones/easy-table/components/common/global-search/global-search.component.d.ts

@@ -0,0 +1,16 @@
+import { OnInit } from '@angular/core';
+import { SmzEasyTableState } from '../../../models/smz-easy-table-state';
+import { TableDataSourceService } from '../../../services/table-data-source.service';
+import * as i0 from "@angular/core";
+export declare class GlobalSearchComponent implements OnInit {
+    private readonly destroyRef;
+    state: SmzEasyTableState;
+    dataSource: TableDataSourceService;
+    value: string;
+    private dataChanged;
+    ngOnInit(): void;
+    onSearchChange(event: any): void;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<GlobalSearchComponent, "et-global-search", never, { "state": { "alias": "state"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/standalones/easy-table/components/common/pagination/pagination.component.d.ts

@@ -0,0 +1,15 @@
+import { OnInit } from '@angular/core';
+import { SmzEasyTableState } from '../../../models/smz-easy-table-state';
+import { TableDataSourceService } from '../../../services/table-data-source.service';
+import * as i0 from "@angular/core";
+export declare class PaginationComponent implements OnInit {
+    state: SmzEasyTableState;
+    dataSource: TableDataSourceService;
+    constructor();
+    ngOnInit(): void;
+    next(): void;
+    previous(): void;
+    goTo(page: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PaginationComponent, "et-pagination", never, { "state": { "alias": "state"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/standalones/easy-table/components/common/sort/sort.component.d.ts

@@ -0,0 +1,15 @@
+import { OnInit, ChangeDetectorRef } from '@angular/core';
+import { SmzEasyTableHeader, SmzEasyTableState } from '../../../models/smz-easy-table-state';
+import { TableDataSourceService } from '../../../services/table-data-source.service';
+import * as i0 from "@angular/core";
+export declare class SortComponent implements OnInit {
+    private cdf;
+    state: SmzEasyTableState;
+    header: SmzEasyTableHeader;
+    dataSource: TableDataSourceService;
+    constructor(cdf: ChangeDetectorRef);
+    ngOnInit(): void;
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SortComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SortComponent, "et-sort", never, { "state": { "alias": "state"; "required": false; }; "header": { "alias": "header"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/standalones/easy-table/components/common/title/title.component.d.ts

@@ -0,0 +1,10 @@
+import { OnInit } from '@angular/core';
+import { SmzEasyTableState } from '../../../models/smz-easy-table-state';
+import * as i0 from "@angular/core";
+export declare class TitleComponent implements OnInit {
+    state: SmzEasyTableState;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TitleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TitleComponent, "et-title", never, { "state": { "alias": "state"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/standalones/easy-table/components/desktop/body/body.component.d.ts

@@ -0,0 +1,16 @@
+import { OnInit } from '@angular/core';
+import { SmzEasyTableContentType } from '../../../models/smz-easy-table-contents';
+import { SmzEasyTableState } from '../../../models/smz-easy-table-state';
+import { TableContentService } from '../../../services/table-content.service';
+import { TableDataSourceService } from '../../../services/table-data-source.service';
+import * as i0 from "@angular/core";
+export declare class DesktopBodyComponent implements OnInit {
+    state: SmzEasyTableState;
+    dataSource: TableDataSourceService;
+    contentService: TableContentService;
+    type: typeof SmzEasyTableContentType;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DesktopBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DesktopBodyComponent, "[et-desktop-body]", never, { "state": { "alias": "state"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "contentService": { "alias": "contentService"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/standalones/easy-table/components/desktop/head/head.component.d.ts

@@ -0,0 +1,12 @@
+import { OnInit } from '@angular/core';
+import { SmzEasyTableState } from '../../../models/smz-easy-table-state';
+import { TableDataSourceService } from '../../../services/table-data-source.service';
+import * as i0 from "@angular/core";
+export declare class DesktopHeadComponent implements OnInit {
+    state: SmzEasyTableState;
+    dataSource: TableDataSourceService;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DesktopHeadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DesktopHeadComponent, "[et-desktop-head]", never, { "state": { "alias": "state"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/standalones/easy-table/containers/desktop/desktop-table.component.d.ts

@@ -0,0 +1,14 @@
+import { OnInit } from '@angular/core';
+import { SmzEasyTableState } from '../../models/smz-easy-table-state';
+import { TableContentService } from '../../services/table-content.service';
+import { TableDataSourceService } from '../../services/table-data-source.service';
+import * as i0 from "@angular/core";
+export declare class DesktopTableComponent implements OnInit {
+    state: SmzEasyTableState;
+    dataSource: TableDataSourceService;
+    contentService: TableContentService;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DesktopTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DesktopTableComponent, "et-desktop-table", never, { "state": { "alias": "state"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "contentService": { "alias": "contentService"; "required": false; }; }, {}, never, never, false, never>;
+}