@ngx-smz/core 19.2.0

package/lib/state/database/ui-definitions/ui-definitions.service.d.ts

@@ -0,0 +1,14 @@
+import { HttpClient } from '@angular/common/http';
+import { BaseApiService } from '../../../modules/rbk-utils/http/base-api.service';
+import { Observable } from 'rxjs';
+import { FormDefinitionData } from '../../../builders/smz-dialogs/dialog-input-conversion';
+import * as i0 from "@angular/core";
+export declare class UiDefinitionsService extends BaseApiService {
+    private http;
+    constructor(http: HttpClient);
+    all(): Observable<{
+        [key: string]: FormDefinitionData;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiDefinitionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiDefinitionsService>;
+}

package/lib/state/database/ui-definitions/ui-definitions.state.d.ts

@@ -0,0 +1,22 @@
+import { StateContext } from '@ngxs/store';
+import { UiDefinitionsDbActions } from './ui-definitions.actions';
+import { UiDefinitionsService } from './ui-definitions.service';
+import { Observable } from 'rxjs';
+import { FormDefinitionData } from '../../../builders/smz-dialogs/dialog-input-conversion';
+import * as i0 from "@angular/core";
+export declare const UI_DEFINITIONS_STATE_NAME = "uiDefinitions";
+export interface UiDefinitionsDbStateModel {
+    lastUpdated: Date;
+    data: {
+        [key: string]: FormDefinitionData;
+    };
+}
+export declare const getUiDefinitionsInitialState: () => UiDefinitionsDbStateModel;
+export declare class UiDefinitionsDbState {
+    private apiService;
+    constructor(apiService: UiDefinitionsService);
+    loadAll(ctx: StateContext<UiDefinitionsDbStateModel>, action: UiDefinitionsDbActions.LoadAll): Observable<any[]>;
+    inject(ctx: StateContext<UiDefinitionsDbStateModel>, action: UiDefinitionsDbActions.Inject): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiDefinitionsDbState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiDefinitionsDbState>;
+}

package/lib/state/database/ui-localization/ui-localization.actions.d.ts

@@ -0,0 +1,16 @@
+import { SmzUiLocale } from './ui-localization.state';
+export declare namespace UiLocalizationDbActions {
+    class LoadAll {
+        static readonly type = "[UI Localization API] Load All";
+    }
+    class SetLocales {
+        locales: SmzUiLocale[];
+        static readonly type = "[UI Localization API] Set Locales";
+        constructor(locales: SmzUiLocale[]);
+    }
+    class SetCurrent {
+        current: string;
+        static readonly type = "[UI Localization API] Set Current";
+        constructor(current: string);
+    }
+}

package/lib/state/database/ui-localization/ui-localization.selectors.d.ts

@@ -0,0 +1,6 @@
+import { SmzUiLocale, UiLocalizationDbStateModel } from './ui-localization.state';
+export declare class UiLocalizationDbSelectors {
+    static all(state: UiLocalizationDbStateModel): any;
+    static locales(state: UiLocalizationDbStateModel): SmzUiLocale[];
+    static current(state: UiLocalizationDbStateModel): SmzUiLocale;
+}

package/lib/state/database/ui-localization/ui-localization.service.d.ts

@@ -0,0 +1,14 @@
+import { HttpClient } from '@angular/common/http';
+import { BaseApiService } from '../../../modules/rbk-utils/http/base-api.service';
+import { Observable } from 'rxjs';
+import { FormDefinitionData } from '../../../builders/smz-dialogs/dialog-input-conversion';
+import * as i0 from "@angular/core";
+export declare class UiLocalizationService extends BaseApiService {
+    private http;
+    constructor(http: HttpClient);
+    all(locale: string): Observable<{
+        [key: string]: FormDefinitionData;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiLocalizationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiLocalizationService>;
+}

package/lib/state/database/ui-localization/ui-localization.state.d.ts

@@ -0,0 +1,27 @@
+import { StateContext } from '@ngxs/store';
+import { UiLocalizationDbActions } from './ui-localization.actions';
+import { UiLocalizationService } from './ui-localization.service';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface SmzUiLocale {
+    code: string;
+    name: string;
+    country: string;
+}
+export declare const UI_LOCALIZATION_STATE_NAME = "uiLocalization";
+export interface UiLocalizationDbStateModel {
+    lastUpdated: Date;
+    current: string;
+    locales: SmzUiLocale[];
+    data: any;
+}
+export declare const getUiLocalizationInitialState: () => UiLocalizationDbStateModel;
+export declare class UiLocalizationDbState {
+    private apiService;
+    constructor(apiService: UiLocalizationService);
+    onLoadAll$(ctx: StateContext<UiLocalizationDbStateModel>, action: UiLocalizationDbActions.LoadAll): Observable<any[]>;
+    onSetCurrent$(ctx: StateContext<UiLocalizationDbStateModel>, action: UiLocalizationDbActions.SetCurrent): void;
+    onSetLocales$(ctx: StateContext<UiLocalizationDbStateModel>, action: UiLocalizationDbActions.SetLocales): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UiLocalizationDbState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UiLocalizationDbState>;
+}

package/lib/state/features/features.actions.d.ts

@@ -0,0 +1,8 @@
+export declare namespace FeaturesActions {
+    class Clear {
+        static readonly type = "[Features State] Clear";
+    }
+    class Restore {
+        static readonly type = "[Features State] Restore";
+    }
+}

package/lib/state/features/features.selectors.d.ts

@@ -0,0 +1,3 @@
+export declare class FeaturesSelectors {
+    static areStatesInitialized(states: string[]): (state: any) => boolean;
+}

package/lib/state/features/features.state.d.ts

@@ -0,0 +1,10 @@
+import { StateContext } from '@ngxs/store';
+import * as i0 from "@angular/core";
+export declare const FEATURE_STATES: any[];
+export declare class FeaturesState {
+    constructor();
+    clear(ctx: StateContext<any>): void;
+    restore(ctx: StateContext<any>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeaturesState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FeaturesState>;
+}

package/lib/state/global/application/application.actions.d.ts

@@ -0,0 +1,55 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { LogInfo } from './application.state';
+export declare namespace ApplicationActions {
+    class HandleHttpErrorWithDialog {
+        error: HttpErrorResponse;
+        static readonly type = "[Application] Handle Http Error With Dialog";
+        constructor(error: HttpErrorResponse);
+    }
+    class HandleHttpErrorWithToast {
+        error: HttpErrorResponse;
+        static readonly type = "[Application] Handle Http Error With Toast";
+        constructor(error: HttpErrorResponse);
+    }
+    class StartGlobalLoading {
+        static readonly type = "[Application] Start Global Loader";
+    }
+    class StopGlobalLoading {
+        static readonly type = "[Application] Stop Global Loader";
+    }
+    class NgRxInitialized {
+        static readonly type = "[Application] NgRx Initialized on Client Application";
+        constructor();
+    }
+    class PushLocalLoading {
+        tag: string;
+        static readonly type = "[Application] Push Local Loading Tag";
+        constructor(tag: string);
+    }
+    class PopLocalLoading {
+        tag: string;
+        static readonly type = "[Application] Pop Local Loading Tag";
+        constructor(tag: string);
+    }
+    class SetLogInfo {
+        info: LogInfo;
+        static readonly type = "[Application] Set Log Information";
+        constructor(info: LogInfo);
+    }
+    class SetLogApplicatinArea {
+        area: string;
+        static readonly type = "[Application] Set Log Application Area";
+        constructor(area: string);
+    }
+    class SetLogExtraData {
+        data: string;
+        static readonly type = "[Application] Set Log Extra Data";
+        constructor(data: string);
+    }
+    class SetLogApplicationAreaAndExtraData {
+        area: string;
+        data: string;
+        static readonly type = "[Application] Set Application Area and Log Extra Data";
+        constructor(area: string, data: string);
+    }
+}

package/lib/state/global/application/application.actions.toast.d.ts

@@ -0,0 +1,32 @@
+import { Message } from '../../../modules/smz-toast/toast';
+export declare namespace ToastActions {
+    class Custom {
+        message: Partial<Message>;
+        static readonly type = "[Application] Show General Toast Message";
+        constructor(message: Partial<Message>);
+    }
+    class Success {
+        message: string;
+        title?: string;
+        static readonly type = "[Application] Show Success Toast Message";
+        constructor(message: string, title?: string);
+    }
+    class Info {
+        message: string;
+        title?: string;
+        static readonly type = "[Application] Show Info Toast Message";
+        constructor(message: string, title?: string);
+    }
+    class Warning {
+        message: string;
+        title?: string;
+        static readonly type = "[Application] Show Warning Toast Message";
+        constructor(message: string, title?: string);
+    }
+    class Error {
+        message: string;
+        title?: string;
+        static readonly type = "[Application] Show Error Toast Message";
+        constructor(message: string, title?: string);
+    }
+}

package/lib/state/global/application/application.selector.d.ts

@@ -0,0 +1,6 @@
+import { ApplicationStateModel, LogInfo } from './application.state';
+export declare class ApplicationSelectors {
+    static globalIsLoading(state: ApplicationStateModel): boolean;
+    static isWaitingRequest(tag: string): any;
+    static logInfo(state: ApplicationStateModel): LogInfo;
+}

package/lib/state/global/application/application.state.d.ts

@@ -0,0 +1,43 @@
+import { StateContext, Store } from '@ngxs/store';
+import { ApplicationActions } from './application.actions';
+import { ToastActions } from './application.actions.toast';
+import { ToastService } from '../../../modules/rbk-utils/misc/toast.service';
+import * as i0 from "@angular/core";
+export interface ApplicationStateModel {
+    globalIsLoading: boolean;
+    localIsLoading: string[];
+    isNgRxInitializedOnClient: boolean;
+    logInfo: LogInfo;
+}
+export interface LogInfo {
+    applicationArea: string;
+    applicationLayer: string;
+    applicationVersion: string;
+    extraData: string;
+}
+export declare const getInitialApplicationState: () => ApplicationStateModel;
+export declare const getCleanApplicationState: () => ApplicationStateModel;
+export declare class ApplicationState {
+    private toastService;
+    private store;
+    constructor(toastService: ToastService, store: Store);
+    handleErrorWithDialog$(ctx: StateContext<ApplicationStateModel>, action: ApplicationActions.HandleHttpErrorWithDialog): Promise<void>;
+    handleErrorWithToast$(ctx: StateContext<ApplicationStateModel>, action: ApplicationActions.HandleHttpErrorWithToast): Promise<void>;
+    startLoading$(ctx: StateContext<ApplicationStateModel>, action: ApplicationActions.StartGlobalLoading): void;
+    stopLoading$(ctx: StateContext<ApplicationStateModel>, action: ApplicationActions.StopGlobalLoading): void;
+    pushLocalLoading$(ctx: StateContext<ApplicationStateModel>, action: ApplicationActions.PushLocalLoading): void;
+    popLocalLoading$(ctx: StateContext<ApplicationStateModel>, action: ApplicationActions.PopLocalLoading): void;
+    logout(ctx: StateContext<ApplicationStateModel>): void;
+    showToastMessage(ctx: StateContext<ApplicationStateModel>, action: ToastActions.Custom): void;
+    showToastSuccessMessage(ctx: StateContext<ApplicationStateModel>, action: ToastActions.Success): void;
+    showToastErrorMessage(ctx: StateContext<ApplicationStateModel>, action: ToastActions.Error): void;
+    showToastInfoMessage(ctx: StateContext<ApplicationStateModel>, action: ToastActions.Info): void;
+    showToastWarningMessage(ctx: StateContext<ApplicationStateModel>, action: ToastActions.Warning): void;
+    setRequiredDatabaseActions(ctx: StateContext<ApplicationStateModel>): void;
+    setLogInfo(ctx: StateContext<ApplicationStateModel>, action: ApplicationActions.SetLogInfo): void;
+    setArea(ctx: StateContext<ApplicationStateModel>, action: ApplicationActions.SetLogApplicatinArea): void;
+    setExtraData(ctx: StateContext<ApplicationStateModel>, action: ApplicationActions.SetLogExtraData): void;
+    setApplicationAreaAndExtraData(ctx: StateContext<ApplicationStateModel>, action: ApplicationActions.SetLogApplicationAreaAndExtraData): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApplicationState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApplicationState>;
+}

package/lib/state/global/authentication/authentication.actions.d.ts

@@ -0,0 +1,42 @@
+import { LoginPayload } from '../../../modules/rbk-utils/auth/auth.service';
+import { SwitchTenant as SwitchTenantRequest } from '../../../modules/smz-access/models/switch-tenant';
+export declare namespace AuthenticationActions {
+    class LocalLogin {
+        static readonly type = "[Auth] Local Login";
+    }
+    class LocalLoginSuccess {
+        static readonly type = "[Auth] Local Login Success";
+        constructor();
+    }
+    class LocalLoginFailure {
+        static readonly type = "[Auth] Local Login Failure";
+        constructor();
+    }
+    class RemoteLogin {
+        data: LoginPayload;
+        static readonly type = "[Auth API] Remote Login";
+        constructor(data: LoginPayload);
+    }
+    class RemoteLoginSuccess {
+        accessToken: string;
+        refreshToken: string;
+        static readonly type = "[Auth API] Remote Login Success";
+        constructor(accessToken: string, refreshToken: string);
+    }
+    class RefreshTokenSuccess {
+        accessToken: string;
+        refreshToken: string;
+        static readonly type = "[Auth API] Refresh Token Success";
+        constructor(accessToken: string, refreshToken: string);
+    }
+    class Logout {
+        redirectTo?: string;
+        static readonly type = "[Auth] Logout";
+        constructor(redirectTo?: string);
+    }
+    class SwitchTenant {
+        data: SwitchTenantRequest;
+        static readonly type = "[Auth API] Switch Tenant";
+        constructor(data: SwitchTenantRequest);
+    }
+}

package/lib/state/global/authentication/authentication.selectors.d.ts

@@ -0,0 +1,14 @@
+import { AuthenticationStateModel } from './authentication.state';
+import { BaseUserData } from '../../../modules/smz-access/models/base-user-data';
+export declare class AuthenticationSelectors {
+    static accessToken(state: AuthenticationStateModel<BaseUserData>): string | null;
+    static refreshToken(state: AuthenticationStateModel<BaseUserData>): string | null;
+    static isAuthenticated(state: AuthenticationStateModel<BaseUserData>): boolean;
+    static userdata(state: AuthenticationStateModel<BaseUserData>): BaseUserData;
+    static userdataPicture(state: AuthenticationStateModel<BaseUserData>): string;
+    static username(state: AuthenticationStateModel<BaseUserData>): string;
+    static isSuperuserLogged(state: AuthenticationStateModel<BaseUserData>): boolean;
+    static hasGroupOfClaimAccess(claims: string[]): any;
+    static hasAnyOfClaimAccess(claims: string[]): any;
+    static hasClaimAccess(claim: string): any;
+}

package/lib/state/global/authentication/authentication.state.d.ts

@@ -0,0 +1,28 @@
+import { StateContext } from '@ngxs/store';
+import { AuthenticationActions } from './authentication.actions';
+import { Observable } from 'rxjs';
+import { AuthService } from '../../../modules/rbk-utils/auth/auth.service';
+import { LoginResponse } from '../../../modules/rbk-utils/auth/models';
+import { AuthenticationService } from '../../../modules/smz-access/services/authentication.service';
+import { JwtResponse } from '../../../modules/smz-access/models/jwt-response';
+import * as i0 from "@angular/core";
+export interface AuthenticationStateModel<T> {
+    userdata: T;
+    refreshToken: string | null;
+    accessToken: string | null;
+}
+export declare const getAuthenticationInitialState: () => AuthenticationStateModel<any>;
+export declare class AuthenticationState {
+    private authService;
+    private authenticationService;
+    constructor(authService: AuthService, authenticationService: AuthenticationService);
+    localLogin(ctx: StateContext<AuthenticationStateModel<any>>, action: AuthenticationActions.LocalLogin): void;
+    localLoginFailure(ctx: StateContext<AuthenticationStateModel<any>>, action: AuthenticationActions.LocalLoginFailure): void;
+    remoteLogin(ctx: StateContext<AuthenticationStateModel<any>>, action: AuthenticationActions.RemoteLogin): Observable<LoginResponse>;
+    remoteLoginSuccess(ctx: StateContext<AuthenticationStateModel<any>>, action: AuthenticationActions.RemoteLoginSuccess | AuthenticationActions.RefreshTokenSuccess): void;
+    localLoginSuccess(ctx: StateContext<AuthenticationStateModel<any>>, action: AuthenticationActions.LocalLoginSuccess): void;
+    logout(ctx: StateContext<AuthenticationStateModel<any>>): void;
+    onSwitchTenant(ctx: StateContext<AuthenticationStateModel<any>>, action: AuthenticationActions.SwitchTenant): Observable<JwtResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticationState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthenticationState>;
+}

package/lib/state/global/authentication/authentication.utils.d.ts

@@ -0,0 +1 @@
+export declare function generateUserData(token: string): any;

package/lib/state/global/authentication/legacy-authentication.selectors.d.ts

@@ -0,0 +1,5 @@
+export declare class LegacyAuthenticationSelectors {
+    static hasGroupOfClaimAccess(claims: string[]): any;
+    static hasAnyOfClaimAccess(claims: string[]): any;
+    static hasClaimAccess(claim: string): any;
+}

package/lib/state/global/authentication/tenant-authentication.selectors.d.ts

@@ -0,0 +1,5 @@
+export declare class TenantAuthenticationSelectors {
+    static hasGroupOfClaimAccess(claims: string[]): any;
+    static hasAnyOfClaimAccess(claims: string[]): any;
+    static hasClaimAccess(claim: string): any;
+}

package/lib/state/global/global.actions.d.ts

@@ -0,0 +1,8 @@
+export declare namespace GlobalActions {
+    class Clear {
+        static readonly type = "[Global State] Clear";
+    }
+    class Restore {
+        static readonly type = "[Global State] Restore";
+    }
+}

package/lib/state/global/global.state.d.ts

@@ -0,0 +1,15 @@
+import { StateContext } from '@ngxs/store';
+import { ApplicationStateModel } from './application/application.state';
+import { GlobalActions } from './global.actions';
+import { AuthenticationStateModel } from './authentication/authentication.state';
+import * as i0 from "@angular/core";
+export interface GlobalStateModel {
+    application: ApplicationStateModel;
+    authentication: AuthenticationStateModel<any>;
+}
+export declare const getGlobalInitialState: () => GlobalStateModel;
+export declare class GlobalState {
+    clear(ctx: StateContext<GlobalStateModel>, action: GlobalActions.Clear): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalState>;
+}

package/lib/state/ui/comments/comments.actions.d.ts

@@ -0,0 +1,30 @@
+import { TreeNode } from 'primeng/api';
+import { SmzCommentsDetails } from '../../../modules/smz-comments/models/comments-details';
+import { CreateComment } from '../../../modules/smz-comments/models/create-comment';
+export declare namespace CommentsUiActions {
+    class LoadAll {
+        orderId: string;
+        forceUpdate: boolean;
+        loaderOverride: boolean;
+        static readonly type = "[Comments API] Load All";
+        constructor(orderId: string, forceUpdate?: boolean, loaderOverride?: boolean);
+    }
+    class LoadAllSuccess {
+        orderId: string;
+        items: TreeNode<SmzCommentsDetails>[];
+        static readonly type = "[Comments API] Load All Success";
+        constructor(orderId: string, items: TreeNode<SmzCommentsDetails>[]);
+    }
+    class Create {
+        creation: CreateComment;
+        loaderOverride: boolean;
+        static readonly type = "[Comments API] Create";
+        constructor(creation: CreateComment, loaderOverride?: boolean);
+    }
+    class CreateSuccess {
+        orderId: string;
+        items: TreeNode<SmzCommentsDetails>[];
+        static readonly type = "[Comments API] Create Success";
+        constructor(orderId: string, items: TreeNode<SmzCommentsDetails>[]);
+    }
+}

package/lib/state/ui/comments/comments.selector.d.ts

@@ -0,0 +1,3 @@
+export declare class CommentsUiSelector {
+    static comments(id: string): any;
+}

package/lib/state/ui/comments/comments.service.d.ts

@@ -0,0 +1,18 @@
+import { HttpClient } from '@angular/common/http';
+import { BaseApiService } from '../../../modules/rbk-utils/http/base-api.service';
+import { Observable } from 'rxjs';
+import { TreeNode } from 'primeng/api';
+import { SmzCommentsDetails } from '../../../modules/smz-comments/models/comments-details';
+import { CreateComment } from '../../../modules/smz-comments/models/create-comment';
+import * as i0 from "@angular/core";
+export declare class CommentsService extends BaseApiService {
+    private http;
+    private readonly environment;
+    private endpoint;
+    constructor(http: HttpClient);
+    private getEndpoint;
+    all(id: string, loaderOverride?: boolean): Observable<TreeNode<SmzCommentsDetails>[]>;
+    create(creation: CreateComment, loaderOverride?: false): Observable<TreeNode<SmzCommentsDetails>[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CommentsService>;
+}

package/lib/state/ui/comments/comments.state.d.ts

@@ -0,0 +1,25 @@
+import { StateContext } from '@ngxs/store';
+import { TreeNode } from 'primeng/api';
+import { Observable } from 'rxjs';
+import { SmzCommentsDetails } from '../../../modules/smz-comments/models/comments-details';
+import { DbData } from '../../../modules/smz-faqs/models/faqs';
+import { CommentsUiActions } from './comments.actions';
+import { CommentsService } from './comments.service';
+import * as i0 from "@angular/core";
+export declare const COMMENTS_STATE_NAME = "comments";
+export interface CommentsUiStateModel {
+    comments: {
+        [key: string]: DbData<TreeNode<SmzCommentsDetails>[]>;
+    };
+}
+export declare const getInitialState: () => CommentsUiStateModel;
+export declare class CommentsUiState {
+    private apiService;
+    constructor(apiService: CommentsService);
+    onLoadAll$(ctx: StateContext<CommentsUiStateModel>, action: CommentsUiActions.LoadAll): Observable<TreeNode<SmzCommentsDetails>[]>;
+    onLoadAllSuccess(ctx: StateContext<CommentsUiStateModel>, action: CommentsUiActions.LoadAllSuccess): void;
+    onCreate$(ctx: StateContext<CommentsUiStateModel>, action: CommentsUiActions.Create): Observable<TreeNode<SmzCommentsDetails>[]>;
+    onCreateSuccess(ctx: StateContext<CommentsUiStateModel>, action: CommentsUiActions.CreateSuccess): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CommentsUiState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CommentsUiState>;
+}

package/lib/state/ui/excels/excels.actions.d.ts

@@ -0,0 +1,14 @@
+import { SmzExcelState, SmzExcelsDetails } from '../../../modules/smz-excels/models/smz-excel-table';
+export declare namespace ExcelsUiActions {
+    class GenerateTable {
+        data: SmzExcelState;
+        downloadAfter?: boolean;
+        static readonly type = "[Excels API] Generate Table";
+        constructor(data: SmzExcelState, downloadAfter?: boolean);
+    }
+    class GenerateTableSuccess {
+        data: SmzExcelsDetails;
+        static readonly type = "[Excels API] Generate Table Success";
+        constructor(data: SmzExcelsDetails);
+    }
+}

package/lib/state/ui/excels/excels.service.d.ts

@@ -0,0 +1,12 @@
+import { HttpClient } from '@angular/common/http';
+import { BaseApiService } from '../../../modules/rbk-utils/http/base-api.service';
+import { Observable } from 'rxjs';
+import { SmzExcelState, SmzExcelsDetails } from '../../../modules/smz-excels/models/smz-excel-table';
+import * as i0 from "@angular/core";
+export declare class ExcelsService extends BaseApiService {
+    private http;
+    constructor(http: HttpClient);
+    generateTables(data: SmzExcelState, loaderOverride?: boolean): Observable<SmzExcelsDetails>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExcelsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExcelsService>;
+}

package/lib/state/ui/excels/excels.state.d.ts

@@ -0,0 +1,18 @@
+import { StateContext } from '@ngxs/store';
+import { Observable } from 'rxjs';
+import { SmzExcelsDetails } from '../../../modules/smz-excels/models/smz-excel-table';
+import { ExcelsUiActions } from './excels.actions';
+import { ExcelsService } from './excels.service';
+import * as i0 from "@angular/core";
+export declare const EXCELS_STATE_NAME = "excels";
+export interface ExcelsUiStateModel {
+}
+export declare const getInitialState: () => ExcelsUiStateModel;
+export declare class ExcelsUiState {
+    private apiService;
+    constructor(apiService: ExcelsService);
+    onCreate$(ctx: StateContext<ExcelsUiStateModel>, action: ExcelsUiActions.GenerateTable): Observable<SmzExcelsDetails>;
+    onCreateSuccess(ctx: StateContext<ExcelsUiStateModel>, action: ExcelsUiActions.GenerateTableSuccess): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExcelsUiState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExcelsUiState>;
+}

package/lib/state/ui/layout/layout.actions.d.ts

@@ -0,0 +1,81 @@
+import { SmzExportDialogData } from '../../../modules/smz-export-dialog/smz-export-dialog.model';
+import { BreadcrumbsData } from '../../../modules/smz-layouts/core/models/breadcrumbs';
+import { ColorSchemaDefinition } from '../../../modules/smz-layouts/core/models/color-schemas';
+import { SmzLoader } from '../../../modules/smz-layouts/core/models/loaders';
+import { EdgePositionType, LeftPositionType, RightPositionType, SidePositionType } from '../../../modules/smz-layouts/core/models/positions';
+import { SmzContentTheme } from '../../../modules/smz-layouts/core/models/themes';
+export declare namespace LayoutUiActions {
+    class Initialize {
+        static readonly type = "[LAYOUT UI] Initialize";
+    }
+    class SetColorSchema {
+        data: ColorSchemaDefinition | string;
+        static readonly type = "[LAYOUT UI] Set Color Schema";
+        constructor(data: ColorSchemaDefinition | string);
+    }
+    class SetContentTheme {
+        data: SmzContentTheme;
+        static readonly type = "[LAYOUT UI] Set Content Theme";
+        constructor(data: SmzContentTheme);
+    }
+    class SetGlobalLoader {
+        data: SmzLoader;
+        static readonly type = "[LAYOUT UI] Set Global Loader";
+        constructor(data: SmzLoader);
+    }
+    class ShowConfigAssistance {
+        static readonly type = "[LAYOUT UI] Show Config Assistance";
+    }
+    class HideConfigAssistance {
+        static readonly type = "[LAYOUT UI] Hide Config Assistance";
+    }
+    class SetAssistancePosition {
+        data: SidePositionType;
+        static readonly type = "[LAYOUT UI] Set Assistance Position";
+        constructor(data: SidePositionType);
+    }
+    class SetAssistanceButtonPosition {
+        data: LeftPositionType | RightPositionType;
+        static readonly type = "[LAYOUT UI] Set Assistance Button Position";
+        constructor(data: LeftPositionType | RightPositionType);
+    }
+    class SetTopbarTitle {
+        data: string;
+        static readonly type = "[LAYOUT UI] Set Topbar Title";
+        constructor(data: string);
+    }
+    class SetToastPosition {
+        data: EdgePositionType;
+        static readonly type = "[LAYOUT UI] Set Toast Position";
+        constructor(data: EdgePositionType);
+    }
+    class MoveLayout {
+        data: string;
+        static readonly type = "[LAYOUT UI] Move Layout";
+        constructor(data: string);
+    }
+    class RestoreLayoutPosition {
+        static readonly type = "[LAYOUT UI] Restore Layout Position";
+    }
+    class SetLastUserMouseEvent {
+        data: 'mouseenter' | 'mouseleave';
+        static readonly type = "[LAYOUT UI] Set Last User Mouse Event";
+        constructor(data: 'mouseenter' | 'mouseleave');
+    }
+    class NavigateBack {
+        static readonly type = "[LAYOUT UI] Navigate Back";
+    }
+    class SetBreadcrumbs {
+        data: BreadcrumbsData;
+        static readonly type = "[LAYOUT UI] SetB readcrumbs";
+        constructor(data: BreadcrumbsData);
+    }
+    class ShowExportDialog {
+        data: SmzExportDialogData;
+        static readonly type = "[LAYOUT UI] Show Export Dialog";
+        constructor(data: SmzExportDialogData);
+    }
+    class HideExportDialog {
+        static readonly type = "[LAYOUT UI] Hide Export Dialog";
+    }
+}