@ngx-smz/core 19.2.0

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

@@ -0,0 +1,122 @@
+import { TreeNode } from 'primeng/api';
+import { SmzTreeMenuItem } from '../../modules/smz-trees/models/tree-menu-item';
+import { SmzTreeState } from '../../modules/smz-trees/models/tree-state';
+import { SmzTreeToolbarButton } from '../../modules/smz-trees/models/tree-toolbar-button';
+import { SmzDataSourceTreeBuilder } from './data-source-tree-builder';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzTreeNode } from '../../modules/smz-trees/models/tree-node';
+export declare class SmzTreeBuilder {
+    _state: SmzTreeState;
+    constructor();
+    debugMode(): SmzTreeBuilder;
+    menu(): SmzTreeMenuBuilder;
+    hideHeader(): SmzTreeBuilder;
+    setTitle(title: string): SmzTreeBuilder;
+    toolbar(type: 'rounded-outlined' | 'rounded-filled' | 'rounded-borderless' | 'square-outlined' | 'square-filled' | 'square-borderless'): SmzTreeToolbarBuilder;
+    emptyFeedback(): SmzTreeEmptyFeedbackBuilder;
+    dragAndDrop(): SmzTreeDragAndDropBuilder;
+    setSelection(mode: 'single' | 'multiple' | 'checkbox', propagateUp?: boolean, propagateDown?: boolean): SmzTreeBuilder;
+    disableInitialNodeExpansion(): SmzTreeBuilder;
+    setLoadingIcon(icon: string): SmzTreeBuilder;
+    enableFilter(): SmzTreeBuilder;
+    setFilterPlaceholder(text: string): SmzTreeBuilder;
+    setFilterStyleClass(styleClass: string): SmzTreeBuilder;
+    useSincronization(): SmzTreeBuilder;
+    dataSource(): SmzDataSourceTreeBuilder<SmzTreeBuilder>;
+    build(): SmzTreeState;
+}
+export declare class SmzTreeToolbarBuilder {
+    _treeBuilder: SmzTreeBuilder;
+    constructor(_treeBuilder: SmzTreeBuilder);
+    setAlignment(alignment: 'start' | 'end'): SmzTreeToolbarBuilder;
+    useTreeExpandButtons(expandLabel?: string, collapseLabel?: string): SmzTreeToolbarBuilder;
+    buttons(): SmzTreeToolbarButtonCollectionBuilder;
+    get tree(): SmzTreeBuilder;
+}
+export declare class SmzTreeToolbarButtonCollectionBuilder {
+    private _toolbarBuilder;
+    constructor(_toolbarBuilder: SmzTreeToolbarBuilder);
+    button(label: string, icon?: string): SmzTreeToolbarButtonBuilder;
+    get toolbar(): SmzTreeToolbarBuilder;
+}
+export declare class SmzTreeToolbarButtonBuilder {
+    private _buttonsCollection;
+    private _button;
+    constructor(_buttonsCollection: SmzTreeToolbarButtonCollectionBuilder, _button: SmzTreeToolbarButton);
+    setCallback(callback: (event: MouseEvent, items: TreeNode[], nodes: TreeNode[]) => void): SmzTreeToolbarButtonBuilder;
+    setTooltip(tooltip: string): SmzTreeToolbarButtonBuilder;
+    setColor(color: 'secondary' | 'success' | 'info' | 'warning' | 'help' | 'danger'): SmzTreeToolbarButtonBuilder;
+    get buttons(): SmzTreeToolbarButtonCollectionBuilder;
+}
+export declare class SmzTreeEmptyFeedbackBuilder {
+    _treeBuilder: SmzTreeBuilder;
+    constructor(_treeBuilder: SmzTreeBuilder);
+    setMessage(message: string): SmzTreeEmptyFeedbackBuilder;
+    setExtraInfo(message: string): SmzTreeEmptyFeedbackBuilder;
+    setImage(path: string): SmzTreeEmptyFeedbackBuilder;
+    setButtonLabel(label: string): SmzTreeEmptyFeedbackBuilder;
+    setButtonCallback(callback: (event?: MouseEvent) => void): SmzTreeEmptyFeedbackBuilder;
+    useTreeEmptyMessage(): SmzTreeEmptyFeedbackBuilder;
+    get tree(): SmzTreeBuilder;
+}
+export declare class SmzTreeDragAndDropBuilder {
+    _treeBuilder: SmzTreeBuilder;
+    constructor(_treeBuilder: SmzTreeBuilder);
+    canDrag(type: string): SmzTreeDropBuilder;
+    get tree(): SmzTreeBuilder;
+}
+export declare class SmzTreeMenuBuilder extends SmzBuilderUtilities<SmzTreeMenuBuilder> {
+    _treeBuilder: SmzTreeBuilder;
+    protected that: this;
+    constructor(_treeBuilder: SmzTreeBuilder);
+    withInlineMenu(icon?: string, severity?: 'primary' | 'secondary' | 'success' | 'info' | 'help' | 'danger' | 'contrast'): SmzTreeMenuBuilder;
+    withContextMenu(): SmzTreeMenuBuilder;
+    setExplicitTypes(types: string[]): SmzTreeMenuBuilder;
+    withDynamicItems(callback: (_: SmzTreeDynamicMenuBuilder, node: SmzTreeNode<unknown>) => SmzTreeMenuItem[]): SmzTreeMenuBuilder;
+    caption(label: string, icon?: string): SmzTreeMenuItemBuilder;
+    separator(): SmzTreeMenuBuilder;
+    item(label: string, icon?: string): SmzTreeMenuItemBuilder;
+    get tree(): SmzTreeBuilder;
+}
+export declare class SmzTreeMenuItemBuilder extends SmzBuilderUtilities<SmzTreeMenuItemBuilder> {
+    _menuBuilder: SmzTreeMenuBuilder;
+    private _parent;
+    private _item;
+    protected that: this;
+    constructor(_menuBuilder: SmzTreeMenuBuilder, _parent: SmzTreeMenuItemBuilder, _item: SmzTreeMenuItem);
+    setCallback<T>(callback: (item: T) => void): SmzTreeMenuItemBuilder;
+    setTooltip(tooltip: string): SmzTreeMenuItemBuilder;
+    hideForTypes(...params: string[]): SmzTreeMenuItemBuilder;
+    showForTypes(...params: string[]): SmzTreeMenuItemBuilder;
+    item(label: string, icon?: string): SmzTreeMenuItemBuilder;
+    get parent(): SmzTreeMenuItemBuilder;
+    get menu(): SmzTreeMenuBuilder;
+}
+export declare class SmzTreeDynamicMenuBuilder extends SmzBuilderUtilities<SmzTreeDynamicMenuBuilder> {
+    protected that: this;
+    private _items;
+    constructor();
+    item(label: string, icon?: string): SmzTreeDynamicMenuItemBuilder;
+    separator(): SmzTreeDynamicMenuBuilder;
+    build(): SmzTreeMenuItem[];
+}
+export declare class SmzTreeDynamicMenuItemBuilder extends SmzBuilderUtilities<SmzTreeDynamicMenuItemBuilder> {
+    private _menuBuilder;
+    private _parent;
+    private _item;
+    protected that: this;
+    constructor(_menuBuilder: SmzTreeDynamicMenuBuilder, _parent: SmzTreeDynamicMenuItemBuilder, _item: SmzTreeMenuItem);
+    setCallback<T>(callback: (item: T) => void): SmzTreeDynamicMenuItemBuilder;
+    setTooltip(tooltip: string): SmzTreeDynamicMenuItemBuilder;
+    hideForTypes(...params: string[]): SmzTreeDynamicMenuItemBuilder;
+    showForTypes(...params: string[]): SmzTreeDynamicMenuItemBuilder;
+    item(label: string, icon?: string): SmzTreeDynamicMenuItemBuilder;
+    get parent(): SmzTreeDynamicMenuItemBuilder;
+    get menu(): SmzTreeDynamicMenuBuilder;
+}
+export declare class SmzTreeDropBuilder {
+    private _type;
+    private _parentBuilder;
+    constructor(_type: string, _parentBuilder: SmzTreeDragAndDropBuilder);
+    into(...types: string[]): SmzTreeDragAndDropBuilder;
+}

package/lib/builders/smz-trees/tree-nodes-utility-builder.d.ts

@@ -0,0 +1,28 @@
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { ParentEntity } from '../../common/models/simple-named-entity';
+import { SmzTreeNode } from '../../modules/smz-trees/models/tree-node';
+export declare class SmzTreeNodeUtilityBuilder<TBuilder> extends SmzBuilderUtilities<SmzTreeNodeUtilityBuilder<TBuilder>> {
+    private _builder;
+    private _parentData;
+    private _treeNodes;
+    protected that: this;
+    private isParent;
+    constructor(_builder: TBuilder, _parentData: ParentEntity<string, SmzTreeNode<any>>[], _treeNodes: SmzTreeNode<any>[]);
+    resetStylesClassForAllTypes(): SmzTreeNodeUtilityBuilder<TBuilder>;
+    addToolTipForAllTypes(message: string): SmzTreeNodeUtilityBuilder<TBuilder>;
+    addToolTip(type: string, message: string): SmzTreeNodeUtilityBuilder<TBuilder>;
+    addIcon(type: string, icon: string): SmzTreeNodeUtilityBuilder<TBuilder>;
+    enableSelectionForAllTypes(applyStyles?: boolean): SmzTreeNodeUtilityBuilder<TBuilder>;
+    disableSelectionForAllTypes(applyStyles?: boolean): SmzTreeNodeUtilityBuilder<TBuilder>;
+    enableSelection(type: string, applyStyles?: boolean): SmzTreeNodeUtilityBuilder<TBuilder>;
+    conditionalSelection(callback: (node: SmzTreeNode<unknown>) => boolean | undefined, applyStyles?: boolean): SmzTreeNodeUtilityBuilder<TBuilder>;
+    forEach<TNodeData>(callback: (node: SmzTreeNode<TNodeData>) => void): SmzTreeNodeUtilityBuilder<TBuilder>;
+    forEachType<TNodeData>(type: string, callback: (node: SmzTreeNode<TNodeData>) => void): SmzTreeNodeUtilityBuilder<TBuilder>;
+    disableSelection(type: string, applyStyles?: boolean): SmzTreeNodeUtilityBuilder<TBuilder>;
+    addStylesClass(type: string, styleClass: string): SmzTreeNodeUtilityBuilder<TBuilder>;
+    expandAll(): SmzTreeNodeUtilityBuilder<TBuilder>;
+    collapseAll(): SmzTreeNodeUtilityBuilder<TBuilder>;
+    expand(type: string): SmzTreeNodeUtilityBuilder<TBuilder>;
+    collapse(type: string): SmzTreeNodeUtilityBuilder<TBuilder>;
+    get tree(): TBuilder;
+}

package/lib/builders/smz-ui/authentication-builder.d.ts

@@ -0,0 +1,16 @@
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiAuthenticationLoginBuilder } from './authentication-login-builder';
+import { SmzUiBuilder } from './ui-builder';
+export declare class SmzUiAuthenticationBuilder extends SmzBuilderUtilities<SmzUiAuthenticationBuilder> {
+    private _builder;
+    protected that: this;
+    constructor(_builder: SmzUiBuilder);
+    setLocalStoragePrefix(prefix: string): SmzUiAuthenticationBuilder;
+    setAuthenticatedRoot(path: string): SmzUiAuthenticationBuilder;
+    setNonAuthenticatedRoot(path: string): SmzUiAuthenticationBuilder;
+    mapAccessTokenData(from: string, to: string, type: 'array' | 'string' | 'boolean'): SmzUiAuthenticationBuilder;
+    setTokenResponse(token: string, refreshToken: string): SmzUiAuthenticationBuilder;
+    login(): SmzUiAuthenticationLoginBuilder;
+    setTenantDisplayName(name: string): SmzUiAuthenticationBuilder;
+    get builder(): SmzUiBuilder;
+}

package/lib/builders/smz-ui/authentication-login-builder.d.ts

@@ -0,0 +1,29 @@
+import { NgxSmzUiConfig } from '../../ngx-smz-ui.config';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiAuthenticationBuilder } from './authentication-builder';
+import { LoginResponse } from '../../modules/rbk-utils/auth/models';
+import { SmzGenericMenuBuilder } from '../smz-menu/generic-menu-builder';
+export declare class SmzUiAuthenticationLoginBuilder extends SmzBuilderUtilities<SmzUiAuthenticationLoginBuilder> {
+    private _builder;
+    private _state;
+    protected that: this;
+    constructor(_builder: SmzUiAuthenticationBuilder, _state: NgxSmzUiConfig);
+    overrideAuthenticationUrl(path?: string): SmzUiAuthenticationLoginBuilder;
+    useSingleTenantAplication(tenant: string): SmzUiAuthenticationLoginBuilder;
+    useWindowsAuthentication(): SmzUiAuthenticationLoginBuilder;
+    forceLowercaseUsername(): SmzUiAuthenticationLoginBuilder;
+    allowSuperuser(superuserName?: string, route?: string): SmzUiAuthenticationLoginBuilder;
+    allowTenantSwitching(): SmzUiAuthenticationLoginBuilder;
+    addToLoginPayload(property: string, value: string): SmzUiAuthenticationLoginBuilder;
+    setMessage(message: string): SmzUiAuthenticationLoginBuilder;
+    setLoginButtonLabel(label: string): SmzUiAuthenticationLoginBuilder;
+    setExtraInfo(extraInfo: string): SmzUiAuthenticationLoginBuilder;
+    setLogoType(type: 'horizontal' | 'vertical' | 'icon' | 'typo'): SmzUiAuthenticationLoginBuilder;
+    useCustomLogo(imagePath: string): SmzUiAuthenticationLoginBuilder;
+    setLogoSize(sizes: 'small' | 'medium' | 'large' | 'hero'): SmzUiAuthenticationLoginBuilder;
+    setBackground(styleClass: string): SmzUiAuthenticationLoginBuilder;
+    setCard(styleClass: string): SmzUiAuthenticationLoginBuilder;
+    setRedirectCallback(callback: (response: LoginResponse) => void): SmzUiAuthenticationLoginBuilder;
+    addButtons(): SmzGenericMenuBuilder<SmzUiAuthenticationLoginBuilder>;
+    get authorization(): SmzUiAuthenticationBuilder;
+}

package/lib/builders/smz-ui/authorization-builder.d.ts

@@ -0,0 +1,27 @@
+import { MenuCreation } from '../../modules/smz-layouts/core/models/menu-creation';
+import { NgxSmzUiConfig } from '../../ngx-smz-ui.config';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiClaimsCrudBuilder } from './crud-claims-builder';
+import { SmzUiRolesCrudBuilder } from './crud-roles-builder';
+import { SmzUiTenantCrudBuilder } from './crud-tenant-builder';
+import { SmzUiUsersCrudBuilder } from './crud-users-builder';
+import { SmzUiBuilder } from './ui-builder';
+export declare class SmzUiAuthorizationBuilder<TData> extends SmzBuilderUtilities<SmzUiAuthorizationBuilder<TData>> {
+    private _builder;
+    private _state;
+    protected that: this;
+    _menuLocation: 'navigation-bar' | 'profile';
+    _menu: MenuCreation;
+    constructor(_builder: SmzUiBuilder, _state: NgxSmzUiConfig);
+    setMenuLabel(label: string): SmzUiAuthorizationBuilder<TData>;
+    overrideMenu(location: 'navigation-bar' | 'profile', partial?: Partial<MenuCreation>): SmzUiAuthorizationBuilder<TData>;
+    allowMultipleRolesPerUser(): SmzUiAuthorizationBuilder<TData>;
+    users(): SmzUiUsersCrudBuilder<TData>;
+    roles(): SmzUiRolesCrudBuilder<TData>;
+    claims(): SmzUiClaimsCrudBuilder<TData>;
+    tenants(): SmzUiTenantCrudBuilder<TData>;
+    setHasGroupOfClaimAccessSelector(selector: any): SmzUiAuthorizationBuilder<TData>;
+    setHasAnyOfClaimAccessSelector(selector: any): SmzUiAuthorizationBuilder<TData>;
+    setHasClaimAccessSelector(selector: any): SmzUiAuthorizationBuilder<TData>;
+    get builder(): SmzUiBuilder;
+}

package/lib/builders/smz-ui/crud-claims-builder.d.ts

@@ -0,0 +1,16 @@
+import { MenuCreation } from '../../modules/smz-layouts/core/models/menu-creation';
+import { NgxSmzUiConfig } from '../../ngx-smz-ui.config';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiAuthorizationBuilder } from './authorization-builder';
+export declare class SmzUiClaimsCrudBuilder<TData> extends SmzBuilderUtilities<SmzUiClaimsCrudBuilder<TData>> {
+    private _builder;
+    private _state;
+    protected that: this;
+    private _config;
+    private _menu;
+    constructor(_builder: SmzUiAuthorizationBuilder<TData>, _state: NgxSmzUiConfig);
+    setTitle(title: string): SmzUiClaimsCrudBuilder<TData>;
+    overrideMenu(partial?: Partial<MenuCreation>): SmzUiClaimsCrudBuilder<TData>;
+    hide(): SmzUiClaimsCrudBuilder<TData>;
+    get authorization(): SmzUiAuthorizationBuilder<TData>;
+}

package/lib/builders/smz-ui/crud-roles-builder.d.ts

@@ -0,0 +1,16 @@
+import { MenuCreation } from '../../modules/smz-layouts/core/models/menu-creation';
+import { NgxSmzUiConfig } from '../../ngx-smz-ui.config';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiAuthorizationBuilder } from './authorization-builder';
+export declare class SmzUiRolesCrudBuilder<TData> extends SmzBuilderUtilities<SmzUiRolesCrudBuilder<TData>> {
+    private _builder;
+    private _state;
+    protected that: this;
+    private _config;
+    private _menu;
+    constructor(_builder: SmzUiAuthorizationBuilder<TData>, _state: NgxSmzUiConfig);
+    setTitle(title: string): SmzUiRolesCrudBuilder<TData>;
+    overrideMenu(partial?: Partial<MenuCreation>): SmzUiRolesCrudBuilder<TData>;
+    hide(): SmzUiRolesCrudBuilder<TData>;
+    get authorization(): SmzUiAuthorizationBuilder<TData>;
+}

package/lib/builders/smz-ui/crud-tenant-builder.d.ts

@@ -0,0 +1,16 @@
+import { MenuCreation } from '../../modules/smz-layouts/core/models/menu-creation';
+import { NgxSmzUiConfig } from '../../ngx-smz-ui.config';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiAuthorizationBuilder } from './authorization-builder';
+export declare class SmzUiTenantCrudBuilder<TData> extends SmzBuilderUtilities<SmzUiTenantCrudBuilder<TData>> {
+    private _builder;
+    private _state;
+    protected that: this;
+    private _config;
+    private _menu;
+    constructor(_builder: SmzUiAuthorizationBuilder<TData>, _state: NgxSmzUiConfig);
+    setTitle(title: string): SmzUiTenantCrudBuilder<TData>;
+    overrideMenu(partial?: Partial<MenuCreation>): SmzUiTenantCrudBuilder<TData>;
+    hide(): SmzUiTenantCrudBuilder<TData>;
+    get authorization(): SmzUiAuthorizationBuilder<TData>;
+}

package/lib/builders/smz-ui/crud-users-builder.d.ts

@@ -0,0 +1,25 @@
+import { NgxSmzUiConfig } from '../../ngx-smz-ui.config';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiAuthorizationBuilder } from './authorization-builder';
+import { MenuCreation } from '../../modules/smz-layouts/core/models/menu-creation';
+import { SmzTableBuilder } from '../smz-tables/state-builder';
+import { SmzGenericMenuBuilder } from '../smz-menu/generic-menu-builder';
+import { SmzMenuItem } from '../../modules/smz-menu/models/smz-menu-item';
+export declare class SmzUiUsersCrudBuilder<TData> extends SmzBuilderUtilities<SmzUiUsersCrudBuilder<TData>> {
+    private _builder;
+    private _state;
+    protected that: this;
+    private _config;
+    private _menu;
+    constructor(_builder: SmzUiAuthorizationBuilder<TData>, _state: NgxSmzUiConfig);
+    setTitle(title: string): SmzUiUsersCrudBuilder<TData>;
+    setAvatarPlaceholder(path: string): SmzUiUsersCrudBuilder<TData>;
+    overrideMenu(partial?: Partial<MenuCreation>): SmzUiUsersCrudBuilder<TData>;
+    customTable(callback: () => SmzTableBuilder<TData>, ignoreDefaultMenu?: boolean): SmzUiUsersCrudBuilder<TData>;
+    addButton(button: SmzMenuItem): SmzUiUsersCrudBuilder<TData>;
+    addButtons(): SmzGenericMenuBuilder<SmzUiUsersCrudBuilder<TData>>;
+    hide(): SmzUiUsersCrudBuilder<TData>;
+    allowUserDeactivation(): SmzUiUsersCrudBuilder<TData>;
+    allowUserDeletion(): SmzUiUsersCrudBuilder<TData>;
+    get authorization(): SmzUiAuthorizationBuilder<TData>;
+}

package/lib/builders/smz-ui/database-state-builder.d.ts

@@ -0,0 +1,15 @@
+import { DatabaseStateParameters } from '../../modules/rbk-utils/ngx-rbk-utils.config';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiStatesBuilder } from './states-builder';
+export declare class SmzUiDatabaseStateBuilder extends SmzBuilderUtilities<SmzUiDatabaseStateBuilder> {
+    private _builder;
+    private _parameter;
+    protected that: this;
+    constructor(_builder: SmzUiStatesBuilder, _parameter: DatabaseStateParameters);
+    setState(state: any): SmzUiDatabaseStateBuilder;
+    setClearFunction(callback: () => {}): SmzUiDatabaseStateBuilder;
+    setClearAction(action: any): SmzUiDatabaseStateBuilder;
+    setLoadAction(action: any): SmzUiDatabaseStateBuilder;
+    overrideCacheTimeout(minutes: number): SmzUiDatabaseStateBuilder;
+    get state(): SmzUiStatesBuilder;
+}

package/lib/builders/smz-ui/errors-page-builder.d.ts

@@ -0,0 +1,26 @@
+import { Store } from '@ngxs/store';
+import { CustomError } from '../../modules/rbk-utils/error-handler/error.handler';
+import { NgxSmzUiConfig } from '../../ngx-smz-ui.config';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiBuilder } from './ui-builder';
+export declare class SmzUiErrorsPageBuilder extends SmzBuilderUtilities<SmzUiErrorsPageBuilder> {
+    private _builder;
+    private _state;
+    protected that: this;
+    constructor(_builder: SmzUiBuilder, _state: NgxSmzUiConfig);
+    setRoute(route: string): SmzUiErrorsPageBuilder;
+    setTitle(title: string): SmzUiErrorsPageBuilder;
+    setMessage(message: string): SmzUiErrorsPageBuilder;
+    setImage(path: string): SmzUiErrorsPageBuilder;
+    hookOnError(callback: (error: CustomError, store: Store) => void): SmzUiErrorsPageBuilder;
+    disableClear(): SmzUiErrorsPageBuilder;
+    clearOnError(): SmzUiErrorsPageBuilder;
+    clearOnRedirect(): SmzUiErrorsPageBuilder;
+    keepNavigationHistory(): SmzUiErrorsPageBuilder;
+    keepStates(): SmzUiErrorsPageBuilder;
+    allowGoToLogin(label?: string, styleClass?: string): SmzUiErrorsPageBuilder;
+    addCallbackButton(label: string, callback: () => void, styleClass?: string): SmzUiErrorsPageBuilder;
+    addRouteButton(label: string, redirectTo: string, styleClass?: string): SmzUiErrorsPageBuilder;
+    addButtonWithCondition(label: string, condition: () => boolean, callback: () => void, styleClass?: string): SmzUiErrorsPageBuilder;
+    get builder(): SmzUiBuilder;
+}

package/lib/builders/smz-ui/feature-state-builder.d.ts

@@ -0,0 +1,15 @@
+import { DatabaseStateParameters } from '../../modules/rbk-utils/ngx-rbk-utils.config';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiStatesBuilder } from './states-builder';
+export declare class SmzUiFeatureStateBuilder extends SmzBuilderUtilities<SmzUiFeatureStateBuilder> {
+    private _builder;
+    private _parameter;
+    protected that: this;
+    constructor(_builder: SmzUiStatesBuilder, _parameter: DatabaseStateParameters);
+    setState(state: any): SmzUiFeatureStateBuilder;
+    setClearFunction(callback: () => {}): SmzUiFeatureStateBuilder;
+    setClearAction(action: any): SmzUiFeatureStateBuilder;
+    setLoadAction(action: any): SmzUiFeatureStateBuilder;
+    overrideCacheTimeout(minutes: number): SmzUiFeatureStateBuilder;
+    get state(): SmzUiStatesBuilder;
+}

package/lib/builders/smz-ui/http-behaviors-builder.d.ts

@@ -0,0 +1,9 @@
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiBuilder } from './ui-builder';
+export declare class SmzUiHttpBehaviorsBuilder extends SmzBuilderUtilities<SmzUiHttpBehaviorsBuilder> {
+    private _builder;
+    protected that: this;
+    constructor(_builder: SmzUiBuilder);
+    useErrorToastNotifications(): SmzUiHttpBehaviorsBuilder;
+    get builder(): SmzUiBuilder;
+}

package/lib/builders/smz-ui/layouts-builder.d.ts

@@ -0,0 +1,14 @@
+import { SmzLayoutsConfig } from '../../modules/smz-layouts/core/globals/smz-layouts.config';
+import { SmzLoader } from '../../modules/smz-layouts/core/models/loaders';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiBuilder } from './ui-builder';
+export declare class SmzUiLayoutsBuilder extends SmzBuilderUtilities<SmzUiLayoutsBuilder> {
+    private _builder;
+    protected that: this;
+    constructor(_builder: SmzUiBuilder, config: SmzLayoutsConfig);
+    setLoader(type: SmzLoader): SmzUiLayoutsBuilder;
+    setGlobalLoaderPendingTimeout(timeout: number): SmzUiLayoutsBuilder;
+    setTitle(title: string): SmzUiLayoutsBuilder;
+    setMessage(message: string): SmzUiLayoutsBuilder;
+    get builder(): SmzUiBuilder;
+}

package/lib/builders/smz-ui/localization-builder.d.ts

@@ -0,0 +1,12 @@
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiBuilder } from './ui-builder';
+export declare class SmzUiLocalizationBuilder extends SmzBuilderUtilities<SmzUiLocalizationBuilder> {
+    private _builder;
+    protected that: this;
+    constructor(_builder: SmzUiBuilder);
+    setApiUrl(url: string): SmzUiLocalizationBuilder;
+    addLocale(code: string, name: string, country: string): SmzUiLocalizationBuilder;
+    setDefault(locale: string): SmzUiLocalizationBuilder;
+    allowLocalizationSwitch(): SmzUiLocalizationBuilder;
+    get builder(): SmzUiBuilder;
+}

package/lib/builders/smz-ui/notifications-builder.d.ts

@@ -0,0 +1,19 @@
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiBuilder } from './ui-builder';
+export declare class SmzUiNotificationsBuilder extends SmzBuilderUtilities<SmzUiNotificationsBuilder> {
+    private _builder;
+    protected that: this;
+    constructor(_builder: SmzUiBuilder);
+    setApiUrl(url: string): SmzUiNotificationsBuilder;
+    hideIndicators(): SmzUiNotificationsBuilder;
+    hideRefreshButton(): SmzUiNotificationsBuilder;
+    setWidth(width: string): SmzUiNotificationsBuilder;
+    customStyles(styleClass: string): SmzUiNotificationsBuilder;
+    setZIndex(zIndex: number): SmzUiNotificationsBuilder;
+    setUpdateRate(miliseconds: number): SmzUiNotificationsBuilder;
+    setEmptyMessage(message: string): SmzUiNotificationsBuilder;
+    setTitle(title: string): SmzUiNotificationsBuilder;
+    setItemsPerPage(count: number): SmzUiNotificationsBuilder;
+    setPagination(settings: number[]): SmzUiNotificationsBuilder;
+    get builder(): SmzUiBuilder;
+}

package/lib/builders/smz-ui/states-builder.d.ts

@@ -0,0 +1,14 @@
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiDatabaseStateBuilder } from './database-state-builder';
+import { SmzUiFeatureStateBuilder } from './feature-state-builder';
+import { SmzUiBuilder } from './ui-builder';
+export declare class SmzUiStatesBuilder extends SmzBuilderUtilities<SmzUiStatesBuilder> {
+    private _builder;
+    protected that: this;
+    constructor(_builder: SmzUiBuilder);
+    useCodeGenerator(AUTOGENERATED_DATABASE_STATES: any): SmzUiStatesBuilder;
+    addDatabase(name: string): SmzUiDatabaseStateBuilder;
+    addFeature(name: string): SmzUiFeatureStateBuilder;
+    overrideCacheTimeout(stateName: string, cacheTimeout: number): SmzUiStatesBuilder;
+    get builder(): SmzUiBuilder;
+}

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

@@ -0,0 +1,11 @@
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiBuilder } from './ui-builder';
+export declare class SmzUiTablesBuilder extends SmzBuilderUtilities<SmzUiTablesBuilder> {
+    private _builder;
+    protected that: this;
+    constructor(_builder: SmzUiBuilder);
+    setExportApiAbsoluteUrl(url: string): SmzUiTablesBuilder;
+    setExportApiRelativeUrl(controller: string, endpoint: string): SmzUiTablesBuilder;
+    setExportRequestLimit(limit: number): SmzUiTablesBuilder;
+    get builder(): SmzUiBuilder;
+}

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

@@ -0,0 +1,39 @@
+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 { NgxSmzUiConfig } from '../../ngx-smz-ui.config';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiAuthenticationBuilder } from './authentication-builder';
+import { SmzUiAuthorizationBuilder } from './authorization-builder';
+import { SmzUiStatesBuilder } from './states-builder';
+import { SmzUiLayoutsBuilder } from './layouts-builder';
+import { SmzUiErrorsPageBuilder } from './errors-page-builder';
+import { SmzUiHttpBehaviorsBuilder } from './http-behaviors-builder';
+import { SmzUiNotificationsBuilder } from './notifications-builder';
+import { SmzUiTablesBuilder } from './tables-builder';
+import { SmzUiLocalizationBuilder } from './localization-builder';
+export declare class SmzUiBuilder extends SmzBuilderUtilities<SmzUiBuilder> {
+    protected that: this;
+    _state: NgxSmzUiConfig;
+    constructor();
+    useLegacy(): SmzUiBuilder;
+    disableDiagnostics(): SmzUiBuilder;
+    setDiagnosticsThrottleTime(throttleTime: number): SmzUiBuilder;
+    setJavascriptErrorBehavior(errorHandlingType: 'toast' | 'redirect' | 'none'): SmzUiBuilder;
+    disableUiDefinitions(): SmzUiBuilder;
+    setDialogsConfigManually(config: SmzDialogsConfig): SmzUiBuilder;
+    setRbkUtilsConfigManually(config: Partial<NgxRbkUtilsConfig>): SmzUiBuilder;
+    layouts(config: SmzLayoutsConfig): SmzUiLayoutsBuilder;
+    setApplicationName(name: string): SmzUiBuilder;
+    httpBehaviors(): SmzUiHttpBehaviorsBuilder;
+    notifications(): SmzUiNotificationsBuilder;
+    localization(): SmzUiLocalizationBuilder;
+    authentication(): SmzUiAuthenticationBuilder;
+    authorization<TUserDetails>(): SmzUiAuthorizationBuilder<TUserDetails>;
+    errorsPage(): SmzUiErrorsPageBuilder;
+    tables(): SmzUiTablesBuilder;
+    states(): SmzUiStatesBuilder;
+    debugMode(): SmzUiBuilder;
+    setLocale(language: 'pt-BR' | 'en-US'): SmzUiBuilder;
+    build(): NgxSmzUiConfig;
+}

package/lib/builders/smz-ui-guides/base-styles-builder.d.ts

@@ -0,0 +1,13 @@
+export declare class SmzUiGuideBaseStylesBuilder<TSelf, TBuilder> {
+    private _builder;
+    private _styles;
+    protected that: TSelf;
+    constructor(_builder: TBuilder, _styles: {
+        styleClass: string;
+    });
+    override(styleClass: string): TSelf;
+    darker(): TSelf;
+    blurry(): TSelf;
+    lighter(): TSelf;
+    grayscale(): TSelf;
+}

package/lib/builders/smz-ui-guides/custom-styles-builder.d.ts

@@ -0,0 +1,25 @@
+import { SmzUiGuideBaseStylesBuilder } from './base-styles-builder';
+import { SmzUiGuidesBuilder } from './ui-guides-builder';
+export declare class SmzUiGuidesCustomStylesBuilder {
+    private _builder;
+    constructor(_builder: SmzUiGuidesBuilder);
+    overlay(): SmzUiGuidesOverlayStylesBuilder;
+    blend(): SmzUiGuidesBlendStylesBuilder;
+    highlight(): SmzUiGuidesHighlightStylesBuilder;
+    get customStyles(): SmzUiGuidesBuilder;
+}
+export declare class SmzUiGuidesOverlayStylesBuilder extends SmzUiGuideBaseStylesBuilder<SmzUiGuidesOverlayStylesBuilder, SmzUiGuidesCustomStylesBuilder> {
+    private _customBuilder;
+    constructor(_customBuilder: SmzUiGuidesCustomStylesBuilder);
+    get overlay(): SmzUiGuidesCustomStylesBuilder;
+}
+export declare class SmzUiGuidesBlendStylesBuilder extends SmzUiGuideBaseStylesBuilder<SmzUiGuidesBlendStylesBuilder, SmzUiGuidesCustomStylesBuilder> {
+    private _customBuilder;
+    constructor(_customBuilder: SmzUiGuidesCustomStylesBuilder);
+    get blend(): SmzUiGuidesCustomStylesBuilder;
+}
+export declare class SmzUiGuidesHighlightStylesBuilder extends SmzUiGuideBaseStylesBuilder<SmzUiGuidesHighlightStylesBuilder, SmzUiGuidesCustomStylesBuilder> {
+    private _customBuilder;
+    constructor(_customBuilder: SmzUiGuidesCustomStylesBuilder);
+    get highlight(): SmzUiGuidesCustomStylesBuilder;
+}

package/lib/builders/smz-ui-guides/default-step-builder.d.ts

@@ -0,0 +1,17 @@
+import { SmzUiGuidesBuilder } from './ui-guides-builder';
+export declare class SmzUiGuidesDefaultStepBuilder {
+    private _builder;
+    constructor(_builder: SmzUiGuidesBuilder);
+    setTitle(title: string): SmzUiGuidesDefaultStepBuilder;
+    setContent(content: string): SmzUiGuidesDefaultStepBuilder;
+    setStyles(styleClass: string): SmzUiGuidesDefaultStepBuilder;
+    setWidth(width: string): SmzUiGuidesDefaultStepBuilder;
+    setHeight(height: string): SmzUiGuidesDefaultStepBuilder;
+    offsetX(percentage: number): SmzUiGuidesDefaultStepBuilder;
+    offsetY(percentage: number): SmzUiGuidesDefaultStepBuilder;
+    horizontal(): SmzUiGuidesDefaultStepBuilder;
+    vertical(): SmzUiGuidesDefaultStepBuilder;
+    disableHighlight(): SmzUiGuidesDefaultStepBuilder;
+    setHighlightMargin(margin: number): SmzUiGuidesDefaultStepBuilder;
+    get defaults(): SmzUiGuidesBuilder;
+}

package/lib/builders/smz-ui-guides/step-builder.d.ts

@@ -0,0 +1,23 @@
+import { SmzUiGuidesBuilder } from './ui-guides-builder';
+export declare class SmzUiGuidesStepBuilder {
+    private _builder;
+    private elementId;
+    private _step;
+    private canAccess;
+    constructor(_builder: SmzUiGuidesBuilder, elementId: string);
+    forClaim(claim: string): SmzUiGuidesStepBuilder;
+    notForClaim(claim: string): SmzUiGuidesStepBuilder;
+    forClaims(canAccessClaims: string[]): SmzUiGuidesStepBuilder;
+    setTitle(title: string): SmzUiGuidesStepBuilder;
+    setContent(content: string): SmzUiGuidesStepBuilder;
+    setStyles(styleClass: string): SmzUiGuidesStepBuilder;
+    setWidth(width: string): SmzUiGuidesStepBuilder;
+    setHeight(height: string): SmzUiGuidesStepBuilder;
+    offsetX(percentage: number): SmzUiGuidesStepBuilder;
+    offsetY(percentage: number): SmzUiGuidesStepBuilder;
+    horizontal(): SmzUiGuidesStepBuilder;
+    vertical(): SmzUiGuidesStepBuilder;
+    disableHighlight(): SmzUiGuidesStepBuilder;
+    setHighlightMargin(margin: number): SmzUiGuidesStepBuilder;
+    get step(): SmzUiGuidesBuilder;
+}

package/lib/builders/smz-ui-guides/step-overrides-builder.d.ts

@@ -0,0 +1,17 @@
+import { SmzUiGuidesBuilder } from './ui-guides-builder';
+export declare class SmzUiGuidesStepOverridesBuilder {
+    private _builder;
+    constructor(_builder: SmzUiGuidesBuilder);
+    setTitle(title: string): SmzUiGuidesStepOverridesBuilder;
+    setContent(content: string): SmzUiGuidesStepOverridesBuilder;
+    setStyles(styleClass: string): SmzUiGuidesStepOverridesBuilder;
+    setWidth(width: string): SmzUiGuidesStepOverridesBuilder;
+    setHeight(height: string): SmzUiGuidesStepOverridesBuilder;
+    offsetX(percentage: number): SmzUiGuidesStepOverridesBuilder;
+    offsetY(percentage: number): SmzUiGuidesStepOverridesBuilder;
+    horizontal(): SmzUiGuidesStepOverridesBuilder;
+    vertical(): SmzUiGuidesStepOverridesBuilder;
+    disableHighlight(): SmzUiGuidesStepOverridesBuilder;
+    setHighlightMargin(margin: number): SmzUiGuidesStepOverridesBuilder;
+    get override(): SmzUiGuidesBuilder;
+}

package/lib/builders/smz-ui-guides/ui-guides-builder.d.ts

@@ -0,0 +1,22 @@
+import { SmzUiGuidesState, SmzUiGuidesStep } from '../../standalones/smz-ui-guides/models/smz-ui-guides-state';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzUiGuidesCustomStylesBuilder } from './custom-styles-builder';
+import { SmzUiGuidesDefaultStepBuilder } from './default-step-builder';
+import { SmzUiGuidesStepBuilder } from './step-builder';
+import { SmzUiGuidesStepOverridesBuilder } from './step-overrides-builder';
+export declare class SmzUiGuidesBuilder extends SmzBuilderUtilities<SmzUiGuidesBuilder> {
+    protected that: this;
+    _state: SmzUiGuidesState;
+    _defaultStep: SmzUiGuidesStep;
+    constructor();
+    defaults(): SmzUiGuidesDefaultStepBuilder;
+    step(elementId: string): SmzUiGuidesStepBuilder;
+    override(): SmzUiGuidesStepOverridesBuilder;
+    setInitCallback(callback: (step: SmzUiGuidesStep) => void): SmzUiGuidesBuilder;
+    setConcludedCallback(callback: (step: SmzUiGuidesStep) => void): SmzUiGuidesBuilder;
+    setLocale(language: 'pt-BR' | 'en-US'): SmzUiGuidesBuilder;
+    allowBackNavigation(): SmzUiGuidesBuilder;
+    showSummaryCount(): SmzUiGuidesBuilder;
+    customStyles(): SmzUiGuidesCustomStylesBuilder;
+    build(): SmzUiGuidesState;
+}