@ngx-smz/core 19.2.0

package/lib/modules/rbk-utils/auth/auth.guard.d.ts

@@ -0,0 +1,10 @@
+import { Store } from '@ngxs/store';
+import { CanActivate, ActivatedRouteSnapshot } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class RbkAuthGuard implements CanActivate {
+    private store;
+    constructor(store: Store);
+    canActivate(snapshot: ActivatedRouteSnapshot): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RbkAuthGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RbkAuthGuard>;
+}

package/lib/modules/rbk-utils/auth/auth.handler.d.ts

@@ -0,0 +1,16 @@
+import { Store } from '@ngxs/store';
+import { AuthService } from './auth.service';
+import { Observable } from 'rxjs';
+import { DiagnosticsService } from '../error-handler/diagnostic.service';
+import * as i0 from "@angular/core";
+export declare class AuthHandler {
+    private authService;
+    private store;
+    private diagnosticsService;
+    private decoder;
+    constructor(authService: AuthService, store: Store, diagnosticsService: DiagnosticsService);
+    getToken(): Observable<string | null>;
+    refreshToken(): Observable<string | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthHandler>;
+}

package/lib/modules/rbk-utils/auth/auth.interceptor.d.ts

@@ -0,0 +1,17 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Store } from '@ngxs/store';
+import { DiagnosticsService } from '../error-handler/diagnostic.service';
+import * as i0 from "@angular/core";
+export declare class AuthInterceptor implements HttpInterceptor {
+    private injector;
+    private store;
+    private diagnosticsService;
+    private config;
+    constructor(injector: Injector, store: Store, diagnosticsService: DiagnosticsService);
+    private inflightAuthRequest;
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthInterceptor>;
+}

package/lib/modules/rbk-utils/auth/auth.service.d.ts

@@ -0,0 +1,24 @@
+import { HttpClient } from '@angular/common/http';
+import { BaseApiService } from '../http/base-api.service';
+import { Observable } from 'rxjs';
+import { LoginResponse } from './models';
+import * as i0 from "@angular/core";
+export interface LoginPayload {
+    username: string;
+    password: string;
+    extraProperties: {
+        [name: string]: string;
+    };
+}
+export declare class AuthService extends BaseApiService {
+    private http;
+    constructor(http: HttpClient);
+    login(username: string, password: string, extraProperties?: {
+        [name: string]: string;
+    }): Observable<LoginResponse>;
+    refreshToken(refreshToken: string, extraProperties?: {
+        [name: string]: string;
+    }): Observable<LoginResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
+}

package/lib/modules/rbk-utils/auth/guards/access-control.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./can-access-if.directive";
+import * as i2 from "./can-access.pipe";
+import * as i3 from "./can-access-any.pipe";
+import * as i4 from "@angular/common";
+export declare class RbkAccessControlModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RbkAccessControlModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RbkAccessControlModule, [typeof i1.RbkClaimGuardDirective, typeof i2.RbkCanAccessPipe, typeof i3.RbkCanAccessAnyPipe], [typeof i4.CommonModule], [typeof i1.RbkClaimGuardDirective, typeof i2.RbkCanAccessPipe, typeof i3.RbkCanAccessAnyPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RbkAccessControlModule>;
+}

package/lib/modules/rbk-utils/auth/guards/can-access-any.pipe.d.ts

@@ -0,0 +1,11 @@
+import { PipeTransform } from '@angular/core';
+import { Store } from '@ngxs/store';
+import * as i0 from "@angular/core";
+export declare class RbkCanAccessAnyPipe implements PipeTransform {
+    private store;
+    constructor(store: Store);
+    transform(claims: string[]): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RbkCanAccessAnyPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RbkCanAccessAnyPipe, "rbkCanAccessAny", false>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RbkCanAccessAnyPipe>;
+}

package/lib/modules/rbk-utils/auth/guards/can-access-if.directive.d.ts

@@ -0,0 +1,12 @@
+import { TemplateRef, ViewContainerRef } from '@angular/core';
+import { Store } from '@ngxs/store';
+import * as i0 from "@angular/core";
+export declare class RbkClaimGuardDirective {
+    private store;
+    private templateRef;
+    private viewContainer;
+    constructor(store: Store, templateRef: TemplateRef<any>, viewContainer: ViewContainerRef);
+    set rbkClaimGuard(claim: string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<RbkClaimGuardDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RbkClaimGuardDirective, "[rbkClaimGuard]", never, { "rbkClaimGuard": { "alias": "rbkClaimGuard"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/modules/rbk-utils/auth/guards/can-access.pipe.d.ts

@@ -0,0 +1,11 @@
+import { PipeTransform } from '@angular/core';
+import { Store } from '@ngxs/store';
+import * as i0 from "@angular/core";
+export declare class RbkCanAccessPipe implements PipeTransform {
+    private store;
+    constructor(store: Store);
+    transform(claim: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RbkCanAccessPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RbkCanAccessPipe, "rbkCanAccess", false>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RbkCanAccessPipe>;
+}

package/lib/modules/rbk-utils/auth/models.d.ts

@@ -0,0 +1,5 @@
+export interface LoginResponse {
+    accessToken: string;
+    refreshToken: string;
+    redirect: any;
+}

package/lib/modules/rbk-utils/error-handler/diagnostic.service.d.ts

@@ -0,0 +1,18 @@
+import { HttpClient } from '@angular/common/http';
+import { BaseApiService } from '../http/base-api.service';
+import { DiagnosticsData } from './diagnostics-data';
+import { Store } from '@ngxs/store';
+import * as i0 from "@angular/core";
+export declare class DiagnosticsService extends BaseApiService {
+    private http;
+    private store;
+    private logSubject;
+    private logSubscription;
+    username: any;
+    constructor(http: HttpClient, store: Store);
+    log(data: DiagnosticsData): void;
+    private actualLogCall;
+    generateDiagnosticsData(): DiagnosticsData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DiagnosticsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DiagnosticsService>;
+}

package/lib/modules/rbk-utils/error-handler/diagnostics-data.d.ts

@@ -0,0 +1,18 @@
+export interface DiagnosticsData {
+    stackTrace: string;
+    inputData: string;
+    applicationArea: string;
+    applicationVersion: string;
+    applicationLayer: string;
+    databaseExceptions: string;
+    exceptionMessage: string;
+    username: string;
+    tenant: string;
+    exceptionSource: string;
+    clientBrowser: string;
+    clientUserAgent: string;
+    clientOperatingSystem: string;
+    clientOperatingSystemVersion: string;
+    clientDevice: string;
+    extraData: string;
+}

package/lib/modules/rbk-utils/error-handler/error.handler.d.ts

@@ -0,0 +1,20 @@
+import { HttpErrorResponse } from '@angular/common/http';
+export type RbkApiErrorMessageTypes = string | string[] | RbkApiErrorMessage;
+interface RbkApiErrorMessage {
+    errors: string[];
+}
+export declare class CustomError {
+    messages: string[];
+    redirectTo: string | null;
+    static getErrorMessages(error: RbkApiErrorMessageTypes): string[];
+    static fromApiResponse(state: HttpErrorResponse): CustomError;
+    static fromExceptionResponse(state: HttpErrorResponse, redirectTo: string): CustomError;
+    static fromSingleError(message: string, redirectTo?: string | null): CustomError;
+    static empty(): CustomError;
+}
+export declare class HttpErrorHandler {
+    static handle(httpResponse: any): Promise<CustomError>;
+    private static isBlobError;
+    private static parseBlob;
+}
+export {};

package/lib/modules/rbk-utils/error-handler/error.interceptor.d.ts

@@ -0,0 +1,14 @@
+import { HttpEvent, HttpInterceptor, HttpHandler, HttpRequest } from '@angular/common/http';
+import { ActivatedRoute, Router } from '@angular/router';
+import { Store } from '@ngxs/store';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class HttpErrorInterceptor implements HttpInterceptor {
+    private store;
+    private route;
+    private router;
+    constructor(store: Store, route: ActivatedRoute, router: Router);
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpErrorInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpErrorInterceptor>;
+}

package/lib/modules/rbk-utils/error-handler/global-error.interceptor.d.ts

@@ -0,0 +1,14 @@
+import { ErrorHandler } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class GlobalErrorHandler implements ErrorHandler {
+    private logSubject;
+    private logSubscription;
+    constructor();
+    handleError(error: any): void;
+    actualHandleError(error: any): Observable<void>;
+    private handleJavascriptError;
+    private submitDiagnostic;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalErrorHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalErrorHandler>;
+}

package/lib/modules/rbk-utils/http/base-api.service.d.ts

@@ -0,0 +1,31 @@
+import { HttpHeaders } from '@angular/common/http';
+export declare const LOADING_BEHAVIOR_HEADER = "Loading-Behavior";
+export declare const ERROR_HANDLING_TYPE_HEADER = "Error-Handling-Type";
+export declare const REFRESH_TOKEN_BEHAVIOR_HEADER = "Refresh-Token-Behavior";
+export declare const WINDOWS_AUTHENTICATION_HEADER = "Windows-Authentication";
+export declare const USER_ID_HEADER = "UserId";
+export declare const AUTHORIZATION_HEADER = "Authorization";
+export declare const CONTENT_ENCODING_HEADER = "Content-Encoding";
+export declare const LOCAL_LOADING_TAG_HEADER = "Local-Loading-Tag";
+export declare const RESTORE_STATE_ON_ERROR_HEADER = "Restore-State-On-Error";
+export declare const IGNORE_ERROR_HANDLING = "Ignore-Error-Handling";
+export declare class BaseApiService {
+    private oneTimeOnlyParameters;
+    private smzUiConfig;
+    withParameters<T extends BaseApiService>(parameters: Partial<HttpBehaviorParameters>): T;
+    protected generateDefaultHeaders(parameters: Partial<HttpBehaviorParameters>): {
+        headers: HttpHeaders;
+    };
+}
+export interface HttpBehaviorParameters {
+    compression: boolean;
+    authentication: boolean;
+    needToRefreshToken: boolean;
+    loadingBehavior: 'global' | 'local' | 'none';
+    errorHandlingType: 'toast' | 'dialog' | 'none';
+    localLoadingTag: string;
+    restoreStateOnError: boolean;
+    ignoreErrorHandling: boolean;
+    useWindowsAuthentication: boolean;
+    mockedUserId: string;
+}

package/lib/modules/rbk-utils/http/global.pending.interceptor.d.ts

@@ -0,0 +1,13 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Store } from '@ngxs/store';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class GlobalPendingInterceptorService implements HttpInterceptor {
+    private store;
+    private pendingRequests;
+    private config;
+    constructor(store: Store);
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GlobalPendingInterceptorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GlobalPendingInterceptorService>;
+}

package/lib/modules/rbk-utils/http/local.pending.interceptor.d.ts

@@ -0,0 +1,11 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Store } from '@ngxs/store';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class LocalPendingInterceptorService implements HttpInterceptor {
+    private store;
+    constructor(store: Store);
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalPendingInterceptorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalPendingInterceptorService>;
+}

package/lib/modules/rbk-utils/misc/boilerplate.service.d.ts

@@ -0,0 +1,16 @@
+import { Actions, Store } from '@ngxs/store';
+import { TitleService } from './title.service';
+import * as i0 from "@angular/core";
+export declare class BoilerplateService {
+    private titleService;
+    private store;
+    private actions$;
+    private subs1;
+    private subs2;
+    private subs3;
+    constructor(titleService: TitleService, store: Store, actions$: Actions);
+    init(callback: () => void): void;
+    private killSubscriptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BoilerplateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BoilerplateService>;
+}

package/lib/modules/rbk-utils/misc/breadcrum.service.d.ts

@@ -0,0 +1,9 @@
+import { MenuItem } from 'primeng/api';
+import * as i0 from "@angular/core";
+export declare class BreadcrumbService {
+    private itemsSource;
+    itemsHandler: import("rxjs").Observable<MenuItem[]>;
+    setItems(items: MenuItem[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BreadcrumbService>;
+}

package/lib/modules/rbk-utils/misc/title.service.d.ts

@@ -0,0 +1,17 @@
+import { Router, ActivatedRoute } from '@angular/router';
+import { Title } from '@angular/platform-browser';
+import { BreadcrumbService } from './breadcrum.service';
+import * as i0 from "@angular/core";
+export declare class TitleService {
+    private router;
+    private activatedRoute;
+    private titleService;
+    private breadcrumbService;
+    private APP_TITLE;
+    private SEPARATOR;
+    constructor(router: Router, activatedRoute: ActivatedRoute, titleService: Title, breadcrumbService: BreadcrumbService);
+    static upperCaseFirstLetter(value: string): any;
+    init(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TitleService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TitleService>;
+}

package/lib/modules/rbk-utils/misc/toast.service.d.ts

@@ -0,0 +1,15 @@
+import { MessageService } from 'primeng/api';
+import { Message } from '../../smz-toast/toast';
+import * as i0 from "@angular/core";
+export declare class ToastService {
+    private messageService;
+    lastMessage: Message;
+    lastUpdated: Date;
+    constructor(messageService: MessageService);
+    add(message: Message): void;
+    private send;
+    private registry;
+    private test;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ToastService>;
+}

package/lib/modules/rbk-utils/ngx-rbk-utils-initialization.d.ts

@@ -0,0 +1,11 @@
+import { Router } from '@angular/router';
+import { ClaimsModule } from '../smz-access/modules/claims/claims.module';
+import { RolesModule } from '../smz-access/modules/roles/roles.module';
+import { TenantsModule } from '../smz-access/modules/tenants/tenants.module';
+import { UsersModule } from '../smz-access/modules/users/users.module';
+export declare function getUsersModule(): typeof UsersModule;
+export declare function getRolesModule(): typeof RolesModule;
+export declare function getClaimsModule(): typeof ClaimsModule;
+export declare function getTenantsModule(): typeof TenantsModule;
+export declare function runAccessRoutesInitialization(router: Router): void;
+export declare function runRbkInitialization(): void;

package/lib/modules/rbk-utils/ngx-rbk-utils.config.d.ts

@@ -0,0 +1,197 @@
+import { Store } from '@ngxs/store';
+import { SmzAuthorizationUserState } from '../smz-access/modules/users/models/smz-authorization-user-state';
+import { SmzDocumentConfig } from '../smz-documents/models/smz-document-config';
+import { MenuCreation } from '../smz-layouts/core/models/menu-creation';
+import { SmzLoginState } from '../smz-layouts/features/login/login-state';
+import { LoginResponse } from './auth/models';
+import { CustomError } from './error-handler/error.handler';
+import { HttpBehaviorParameters } from './http/base-api.service';
+import { SmzUiLocale } from '../../state/database/ui-localization/ui-localization.state';
+import { SmzMenuItem } from '../smz-menu/models/smz-menu-item';
+export declare class NgxRbkUtilsConfig {
+    debugMode: boolean;
+    applicationName: string;
+    useTitleService?: boolean;
+    diagnostics: {
+        url: string;
+        throttleTime: number;
+    };
+    notifications: {
+        url: string;
+        updateMethod?: 'interval';
+        updateRate?: number;
+        httpBehavior?: Partial<HttpBehaviorParameters>;
+        emptyMessage?: string;
+        title?: string;
+        rowsPerPage?: number;
+        pageOptions?: number[];
+        showTypeIndicators?: boolean;
+        showRefreshButton?: boolean;
+        width?: string;
+        styleClass?: string;
+        zIndex?: number;
+        date?: {
+            recentsMethod: 'fromNow' | 'calendar';
+            recentsDaysCount: number;
+            othersFormat: string;
+        };
+    };
+    documents?: {
+        defaultStyles: SmzDocumentConfig;
+    };
+    uiDefinitions: {
+        isEnabled: boolean;
+        url: string;
+        httpBehavior: Partial<HttpBehaviorParameters>;
+    };
+    uiLocalization: {
+        url: string;
+        current: string;
+        locales: SmzUiLocale[];
+        httpBehavior: Partial<HttpBehaviorParameters>;
+        allowLocalizationSwitching: boolean;
+        isEnabled: boolean;
+    };
+    state: {
+        database: {
+            [name: string]: DatabaseStateParameters;
+        };
+        feature: {
+            [name: string]: DatabaseStateParameters;
+        };
+    };
+    authentication: {
+        localStoragePrefix: string;
+        authenticatedRoot: string;
+        nonAuthenticatedRoot: string;
+        allowSuperuser: boolean;
+        useSingleTenantAplication: boolean;
+        allowTenantSwitching: boolean;
+        login: {
+            url: string;
+            route: string;
+            superuserRoute?: string;
+            loadingBehavior: 'global' | 'local' | 'none';
+            errorHandlingType: 'toast' | 'dialog' | 'none';
+            responsePropertyName: string;
+            redirectCallback?: (response: LoginResponse) => void;
+            superuser: string;
+            applicationTenant: string;
+            showTenantSelector: boolean;
+            forceLowercaseUsername?: boolean;
+            page: {
+                useSmzLoginModule: boolean;
+                customButtons?: SmzMenuItem[];
+                state: SmzLoginState<any, any>;
+                overrideState: Partial<SmzLoginState<any, any>>;
+            };
+        };
+        refreshToken: {
+            url: string;
+            loadingBehavior: 'global' | 'local' | 'none';
+            errorHandlingType: 'toast' | 'dialog' | 'none';
+            responsePropertyName: string;
+            extraProperties?: {
+                [name: string]: string;
+            };
+        };
+        accessTokenClaims?: {
+            claimName: string;
+            propertyName: string;
+            type: 'string' | 'array' | 'boolean';
+        }[];
+        useWindowsAuthentication?: boolean;
+    };
+    httpBehaviors: {
+        defaultParameters: HttpBehaviorParameters;
+    };
+    toastConfig: {
+        severity: string;
+        life: number;
+        sticky: boolean;
+        closable: boolean;
+        successTitle: string;
+        warningTitle: string;
+        errorTitle: string;
+        infoTitle: string;
+        debounceDistinctDelay: number;
+    };
+    dialogsConfig: {
+        errorDialogTitle: string;
+        warningDialogTitle: string;
+    };
+    errorsConfig: {
+        page: {
+            title: string;
+            message: string;
+            imagePath: string;
+            route: string;
+            buttons: {
+                isVisible: () => boolean;
+                label?: string;
+                styleClass?: string;
+                redirectTo?: string;
+                callback?: () => void;
+            }[];
+        };
+        clearBehaviors: {
+            method: 'onError' | 'onRedirect' | 'none';
+            globalStates: boolean;
+            databaseStates: boolean;
+            featuresStates: boolean;
+            localStorage: 'appPrefix' | 'none';
+            navigationHistory: boolean;
+        };
+        javascriptErrors: {
+            errorHandlingType: 'toast' | 'redirect' | 'none';
+        };
+        callback?: (error: CustomError, store: Store) => void;
+    };
+    authorization: {
+        navigationMenu: MenuCreation;
+        profileMenu: MenuCreation[];
+        allowMultipleRolesPerUser: boolean;
+        users: SmzAuthorizationUserState<any>;
+        validationSelectors: {
+            hasGroupOfClaimAccess: any;
+            hasAnyOfClaimAccess: any;
+            hasClaimAccess: any;
+        };
+        roles: {
+            title?: string;
+            router?: {
+                path: string;
+                claim?: string;
+            };
+            httpBehavior?: Partial<HttpBehaviorParameters>;
+            isVisible?: boolean;
+        };
+        claims: {
+            title?: string;
+            router?: {
+                path: string;
+                claim?: string;
+            };
+            httpBehavior?: Partial<HttpBehaviorParameters>;
+            isVisible?: boolean;
+        };
+        tenants: {
+            title?: string;
+            router?: {
+                path: string;
+                claim?: string;
+            };
+            httpBehavior?: Partial<HttpBehaviorParameters>;
+            isVisible?: boolean;
+        };
+    };
+}
+export type RoleBehavior = 'single' | 'multiple';
+export interface DatabaseStateParameters {
+    state: any;
+    loadAction?: any;
+    clearAction?: any;
+    successAction?: any;
+    clearFunction?: () => {};
+    cacheTimeout?: number;
+}

package/lib/modules/rbk-utils/ngx-rbk-utils.module.d.ts

@@ -0,0 +1,11 @@
+import { ModuleWithProviders } from '@angular/core';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class NgxRbkUtilsModule {
+    private router;
+    constructor(router: Router);
+    static forRoot(): ModuleWithProviders<NgxRbkUtilsModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxRbkUtilsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxRbkUtilsModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxRbkUtilsModule>;
+}

package/lib/modules/rbk-utils/pipes/rbk-pipes.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./rbk-safe-html.pipe";
+import * as i2 from "@angular/common";
+export declare class RbkPipesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RbkPipesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RbkPipesModule, [typeof i1.rbkSafeHtmlPipe], [typeof i2.CommonModule], [typeof i1.rbkSafeHtmlPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RbkPipesModule>;
+}

package/lib/modules/rbk-utils/pipes/rbk-safe-html.pipe.d.ts

@@ -0,0 +1,10 @@
+import { PipeTransform } from '@angular/core';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+export declare class rbkSafeHtmlPipe implements PipeTransform {
+    private sanitizer;
+    constructor(sanitizer: DomSanitizer);
+    transform(html: string): SafeHtml;
+    static ɵfac: i0.ɵɵFactoryDeclaration<rbkSafeHtmlPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<rbkSafeHtmlPipe, "rbkSafeHtml", false>;
+}

package/lib/modules/rbk-utils/public-api.d.ts

@@ -0,0 +1,27 @@
+export * from './ngx-rbk-utils.module';
+export * from './ngx-rbk-utils.config';
+export * from './utils/utils';
+export * from './utils/operators';
+export * from './utils/reusable-route';
+export * from './utils/state/database-state.guard';
+export * from './utils/state/feature-state.guard';
+export * from './auth/auth.guard';
+export * from './auth/auth.handler';
+export * from './auth/guards/can-access-if.directive';
+export * from './auth/guards/can-access.pipe';
+export * from './auth/guards/can-access-any.pipe';
+export * from './auth/guards/access-control.module';
+export * from './auth/auth.service';
+export * from './auth/models';
+export * from './error-handler/error.handler';
+export * from './http/base-api.service';
+export * from './misc/breadcrum.service';
+export * from './misc/title.service';
+export * from './misc/boilerplate.service';
+export * from './misc/toast.service';
+export * from './ui/input-clear-extension.directive';
+export * from './ui/table-clear-extension.directive';
+export * from './ui/table-clear-extions.module';
+export * from './pipes/rbk-safe-html.pipe';
+export * from './pipes/rbk-pipes.module';
+export { CanAccess } from './utils/can-access';

package/lib/modules/rbk-utils/ui/input-clear-extension.directive.d.ts

@@ -0,0 +1,17 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { TreeTable } from 'primeng/treetable';
+import { Table } from 'primeng/table';
+import * as i0 from "@angular/core";
+export declare class InputClearExtensionDirective implements OnInit, OnDestroy {
+    rbkInputClearExtension: {
+        table: TreeTable | Table;
+        component: any;
+    };
+    private isDirectiveActive;
+    constructor();
+    ngOnInit(): void;
+    clear(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputClearExtensionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InputClearExtensionDirective, "[rbkInputClearExtension]", never, { "rbkInputClearExtension": { "alias": "rbkInputClearExtension"; "required": false; }; }, {}, never, never, false, never>;
+}

package/lib/modules/rbk-utils/ui/table-clear-extension.directive.d.ts

@@ -0,0 +1,11 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class TableClearExtensionDirective implements OnInit {
+    rbkTableClearExtension: any;
+    constructor();
+    ngOnInit(): void;
+    clear(): void;
+    private clearFilters;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableClearExtensionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TableClearExtensionDirective, "[rbkTableClearExtension]", never, { "rbkTableClearExtension": { "alias": "rbkTableClearExtension"; "required": false; }; }, {}, never, never, false, never>;
+}