@acorex/platform 1.0.0

package/README.md

@@ -0,0 +1,7 @@
+# platform
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test platform` to execute the unit tests.

package/auth/README.md

@@ -0,0 +1,3 @@
+# @acorex/platform/auth
+
+Secondary entry point of `@acorex/platform`. It can be used by importing from `@acorex/platform/auth`.

package/auth/index.d.ts

@@ -0,0 +1,16 @@
+export * from './lib/application/application.loader';
+export * from './lib/application/application.types';
+export * from './lib/tenant/tenant.loader';
+export * from './lib/tenant/tenant.types';
+export * from './lib/permission/permission.directive';
+export * from './lib/permission/permission.guard';
+export * from './lib/permission/permission.loader';
+export * from './lib/permission/permission.types';
+export * from './lib/feature/feature.loader';
+export * from './lib/feature/feature.types';
+export * from './lib/user/user.types';
+export * from './lib/auth.guard';
+export * from './lib/auth.module';
+export * from './lib/auth.strategy';
+export * from './lib/errors.types';
+export * from './lib/session.service';

package/auth/lib/application/application.loader.d.ts

@@ -0,0 +1,9 @@
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AXPTokens } from '../auth.strategy';
+import { AXPApplication } from './application.types';
+export interface AXPApplicationLoader {
+    getList(): Observable<AXPApplication[]>;
+    set(application: AXPApplication): Observable<AXPTokens>;
+}
+export declare const AXP_APPLICATION_LOADER: InjectionToken<AXPApplicationLoader>;

package/auth/lib/application/application.types.d.ts

@@ -0,0 +1,10 @@
+import { AXPLogoConfig } from '@acorex/platform/common';
+export interface AXPApplication {
+    id: string;
+    name: string;
+    title: string;
+    version: string;
+    editionName: string;
+    description?: string;
+    logo?: AXPLogoConfig;
+}

package/auth/lib/auth-registry.service.d.ts

@@ -0,0 +1,12 @@
+import { Injector } from "@angular/core";
+import { AXPAuthStrategy } from "./auth.strategy";
+import * as i0 from "@angular/core";
+export declare class AXPAuthStrategyRegistryService {
+    private strategies;
+    private injector;
+    constructor(injector: Injector);
+    register(...plugins: (new () => AXPAuthStrategy)[]): void;
+    get(strategyKey: string): AXPAuthStrategy | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPAuthStrategyRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPAuthStrategyRegistryService>;
+}

package/auth/lib/auth.guard.d.ts

@@ -0,0 +1,2 @@
+import { CanActivateFn } from '@angular/router';
+export declare const AXPAuthGuard: CanActivateFn;

package/auth/lib/auth.module.d.ts

@@ -0,0 +1,20 @@
+import { ModuleWithProviders } from "@angular/core";
+import { AXPAuthStrategy } from "./auth.strategy";
+import { AXPSessionService } from "./session.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./permission/permission.directive";
+export interface AXPAuthModuleConfigs {
+    strategies: (new () => AXPAuthStrategy)[];
+}
+export declare function initializeAppState(service: AXPSessionService): () => Promise<void>;
+export declare class AXPAuthModule {
+    static forRoot(configs?: AXPAuthModuleConfigs): ModuleWithProviders<AXPAuthModule>;
+    static forChild(configs?: AXPAuthModuleConfigs): ModuleWithProviders<AXPAuthModule>;
+    /**
+     * @ignore
+     */
+    constructor(instances: any[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPAuthModule, [{ optional: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPAuthModule, [typeof i1.AXPPermissionDirective], never, [typeof i1.AXPPermissionDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXPAuthModule>;
+}

package/auth/lib/auth.strategy.d.ts

@@ -0,0 +1,28 @@
+import { AXPApplication } from './application/application.types';
+import { AXPTenant } from './tenant/tenant.types';
+import { AXPUser } from './user/user.types';
+export interface AXPBaseCredentials {
+    strategy: string;
+    [key: string]: string;
+}
+export interface AXPTokens {
+    accessToken: string;
+    refreshToken: string;
+    user?: AXPUser;
+    tenant?: AXPTenant;
+    application?: AXPApplication;
+}
+export interface AXPAuthStrategy {
+    get name(): string;
+    signin(credentials: AXPBaseCredentials): Promise<AXPTokens>;
+    signout(): Promise<void>;
+    refreshToken(refreshToken: string): Promise<AXPTokens>;
+}
+export interface AXPSessionData {
+    accessToken: string;
+    refreshToken: string;
+    strategy: string;
+    user?: AXPUser | null;
+    tenant?: AXPTenant | null;
+    application?: AXPApplication | null;
+}

package/auth/lib/errors.types.d.ts

@@ -0,0 +1,6 @@
+export declare class AXPUnauthorizedError extends Error {
+    constructor();
+}
+export declare class AXPUnauthenticatedError extends Error {
+    constructor();
+}

package/auth/lib/feature/feature.loader.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AXPFeature } from './feature.types';
+export interface AXPFeatureLoader {
+    getList(): Observable<AXPFeature[]>;
+}
+export declare const AXP_FEATURE_LOADER: InjectionToken<AXPFeatureLoader>;

package/auth/lib/feature/feature.types.d.ts

@@ -0,0 +1,6 @@
+export interface AXPFeature {
+    name: string;
+    title: string;
+    description?: string;
+    value?: any;
+}

package/auth/lib/permission/permission.directive.d.ts

@@ -0,0 +1,16 @@
+import { TemplateRef, ViewContainerRef } from '@angular/core';
+import { AXPSessionService } from '../session.service';
+import * as i0 from "@angular/core";
+export declare class AXPPermissionDirective {
+    private templateRef;
+    private viewContainer;
+    private sessionService;
+    private hasView;
+    private subscription;
+    private configs;
+    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, sessionService: AXPSessionService);
+    set permission(permissionKey: string | null);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPPermissionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPPermissionDirective, "[permission]", never, { "permission": { "alias": "permission"; "required": false; }; }, {}, never, never, false, never>;
+}

package/auth/lib/permission/permission.guard.d.ts

@@ -0,0 +1,2 @@
+import { CanActivateFn } from "@angular/router";
+export declare const AXPPermissionGuard: CanActivateFn;

package/auth/lib/permission/permission.loader.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken } from "@angular/core";
+import { Observable } from "rxjs";
+import { AXPPermission } from "./permission.types";
+export interface AXPPermissionLoader {
+    getList(): Observable<AXPPermission[]>;
+}
+export declare const AXP_PERMISSION_LOADER: InjectionToken<AXPPermissionLoader>;

package/auth/lib/permission/permission.types.d.ts

@@ -0,0 +1 @@
+export type AXPPermission = string;

package/auth/lib/session.service.d.ts

@@ -0,0 +1,51 @@
+import { Observable } from 'rxjs';
+import { AXPApplication } from './application/application.types';
+import { AXPBaseCredentials } from './auth.strategy';
+import { AXPPermission } from './permission/permission.types';
+import { AXPTenant } from './tenant/tenant.types';
+import { AXPUser } from './user/user.types';
+import * as i0 from "@angular/core";
+export declare class AXPSessionService {
+    private store;
+    private currentAuthStrategyKey;
+    private authStrategyRegistry;
+    private readonly tenantService;
+    private readonly applicationLoader;
+    private readonly permissionLoader;
+    private currentUserSubject;
+    private readonly SESSION_KEY;
+    readonly user$: Observable<AXPUser | null>;
+    get user(): AXPUser | null;
+    private currentTenantSubject;
+    private tenantsSubject;
+    readonly tenants$: Observable<AXPTenant[]>;
+    readonly tenant$: Observable<AXPTenant | null>;
+    get tenant(): AXPTenant | null;
+    private currentApplicationSubject;
+    private applicationsSubject;
+    readonly applications$: Observable<AXPApplication[]>;
+    readonly application$: Observable<AXPApplication | null>;
+    get application(): AXPApplication | null;
+    private permissionsSubject;
+    readonly permissions$: Observable<never[] | string[] | null>;
+    get permissions(): AXPPermission[];
+    readonly isAuthenticated$: Observable<boolean>;
+    readonly isAuthorized$: Observable<boolean>;
+    signInWithStoredSession(): Promise<void>;
+    signin(credentials: AXPBaseCredentials): Promise<void>;
+    signout(): Promise<void>;
+    refreshToken(): Promise<void>;
+    selectTenant(tenantId: string): Promise<void>;
+    selectApplication(applicationId: string): Promise<void>;
+    private loadTenants;
+    private loadApplications;
+    private loadPermissions;
+    private setSession;
+    private updateSession;
+    private getSessionData;
+    private clearSession;
+    authorize(...keys: string[]): boolean;
+    getToken(): Observable<string | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSessionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSessionService>;
+}

package/auth/lib/tenant/tenant.loader.d.ts

@@ -0,0 +1,9 @@
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AXPTokens } from '../auth.strategy';
+import { AXPTenant } from './tenant.types';
+export interface AXPTenantLoader {
+    getList(): Observable<AXPTenant[]>;
+    set(tenant: AXPTenant): Observable<AXPTokens>;
+}
+export declare const AXP_TENANT_LOADER: InjectionToken<AXPTenantLoader>;

package/auth/lib/tenant/tenant.types.d.ts

@@ -0,0 +1,8 @@
+import { AXPLogoConfig } from "@acorex/platform/common";
+export interface AXPTenant {
+    id: string;
+    name: string;
+    title: string;
+    description?: string;
+    logo?: AXPLogoConfig;
+}

package/auth/lib/user/user.types.d.ts

@@ -0,0 +1,6 @@
+export interface AXPUser {
+    id: string;
+    name: string;
+    title: string;
+    avatar?: string;
+}

package/common/README.md

@@ -0,0 +1,3 @@
+# @acorex/platform/common
+
+Secondary entry point of `@acorex/platform`. It can be used by importing from `@acorex/platform/common`.

package/common/index.d.ts

@@ -0,0 +1,11 @@
+export * from './lib/common.module';
+export * from './lib/configs/app.config';
+export * from './lib/data';
+export * from './lib/errors';
+export * from './lib/menu';
+export * from './lib/settings';
+export * from './lib/shared/logo.types';
+export * from './lib/shared/state-persistence';
+export * from './lib/store';
+export * from './lib/utils';
+export * from './lib/layout/component-slot';

package/common/lib/common.module.d.ts

@@ -0,0 +1,21 @@
+import { ModuleWithProviders } from '@angular/core';
+import { AXPErrorHandler } from './errors';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/effects";
+import * as i2 from "@acorex/components/popup";
+import * as i3 from "@acorex/core/dateTime";
+import * as i4 from "@angular/router";
+export interface AXPCommonModuleConfigs {
+    errorHandlers: (new () => AXPErrorHandler)[];
+}
+export declare class AXPCommonModule {
+    static forRoot(configs?: AXPCommonModuleConfigs): ModuleWithProviders<AXPCommonModule>;
+    static forChild(configs?: AXPCommonModuleConfigs): ModuleWithProviders<AXPCommonModule>;
+    /**
+     * @ignore
+     */
+    constructor(instances: any[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPCommonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPCommonModule, never, [typeof i1.EffectsFeatureModule, typeof i2.AXPopupModule, typeof i3.AXDateTimeModule], [typeof i4.RouterModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXPCommonModule>;
+}

package/common/lib/configs/app.config.d.ts

@@ -0,0 +1,19 @@
+import { InjectionToken } from '@angular/core';
+import { AXPLogoConfig } from '../shared/logo.types';
+export declare const AXP_PLATFORM_CONFIG_TOKEN: InjectionToken<AXPPlatformConfigs>;
+export interface AXPPlatformConfigs {
+    title?: string;
+    copyright?: string;
+    logo?: {
+        dark?: AXPLogoConfig;
+        light?: AXPLogoConfig;
+        colored?: AXPLogoConfig;
+    };
+    useLocalData: boolean;
+    network?: {
+        timeOut?: number;
+    };
+    WEATHER_API_TOKEN: string;
+}
+export declare const AXPPlatformDefaultConfigs: AXPPlatformConfigs;
+export declare function configPlatform(config?: Partial<AXPPlatformConfigs>): AXPPlatformConfigs;

package/common/lib/data/data-provider.types.d.ts

@@ -0,0 +1,11 @@
+export declare abstract class AXPDataProvider {
+    abstract insertOne(entity: any, entityItem: any): Promise<any>;
+    abstract insertMany(entity: any, entityList: any): Promise<any>;
+    abstract getOne(entity: any, id: string): Promise<any>;
+    abstract getMany(entity: any, params?: any): Promise<any>;
+    abstract updateOne(entity: any, id: string, data: {
+        [key: string]: any;
+    }): Promise<any>;
+    abstract deleteOne(entity: any, id: string): Promise<any>;
+    abstract getFirst(entity: any): Promise<any>;
+}

package/common/lib/data/index.d.ts

@@ -0,0 +1 @@
+export * from './data-provider.types';

package/common/lib/errors/error-handler-registry.service.d.ts

@@ -0,0 +1,12 @@
+import { Injector } from "@angular/core";
+import { AXPErrorHandler } from "./error-handler.types";
+import * as i0 from "@angular/core";
+export declare class AXPErrorHandlerRegistryService {
+    private injector;
+    private errorHandlers;
+    constructor(injector: Injector);
+    register(...plugins: (new () => AXPErrorHandler)[]): void;
+    get handlers(): AXPErrorHandler[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPErrorHandlerRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPErrorHandlerRegistryService>;
+}

package/common/lib/errors/error-handler.types.d.ts

@@ -0,0 +1,3 @@
+export interface AXPErrorHandler {
+    handleError(error: Error, next: (error: Error) => void): void;
+}

package/common/lib/errors/global-error-handler.d.ts

@@ -0,0 +1,11 @@
+import { ErrorHandler, Injector } from "@angular/core";
+import { AXPErrorHandlerRegistryService } from "./error-handler-registry.service";
+import * as i0 from "@angular/core";
+export declare class AXPGlobalErrorHandler extends ErrorHandler {
+    private injector;
+    private registry;
+    constructor(injector: Injector, registry: AXPErrorHandlerRegistryService);
+    handleError(error: Error): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPGlobalErrorHandler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPGlobalErrorHandler>;
+}

package/common/lib/errors/index.d.ts

@@ -0,0 +1,3 @@
+export * from './error-handler.types';
+export * from './global-error-handler';
+export * from './error-handler-registry.service';

package/common/lib/layout/component-slot/component-slot-loader.service.d.ts

@@ -0,0 +1,11 @@
+import { Injector, ViewContainerRef } from "@angular/core";
+import { AXPComponentSlotRegistryService } from "./component-slot-registery.service";
+import * as i0 from "@angular/core";
+export declare class AXPComponentSlotLoaderService {
+    private registryService;
+    private injector;
+    constructor(registryService: AXPComponentSlotRegistryService, injector: Injector);
+    loadComponent(slotName: string, viewContainerRef: ViewContainerRef): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPComponentSlotLoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPComponentSlotLoaderService>;
+}

package/common/lib/layout/component-slot/component-slot-registery.service.d.ts

@@ -0,0 +1,9 @@
+import { AXPComponentSlotConfig } from "./component-slot.types";
+import * as i0 from "@angular/core";
+export declare class AXPComponentSlotRegistryService {
+    private registry;
+    register(slotName: string, config: AXPComponentSlotConfig): void;
+    get(slotName: string): AXPComponentSlotConfig[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPComponentSlotRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPComponentSlotRegistryService>;
+}

package/common/lib/layout/component-slot/component-slot.directive.d.ts

@@ -0,0 +1,12 @@
+import { OnInit, ViewContainerRef } from '@angular/core';
+import { AXPComponentSlotLoaderService } from './component-slot-loader.service';
+import * as i0 from "@angular/core";
+export declare class AXPComponentSlotDirective implements OnInit {
+    private dynamicLoaderService;
+    viewContainerRef: ViewContainerRef;
+    name: string;
+    constructor(dynamicLoaderService: AXPComponentSlotLoaderService, viewContainerRef: ViewContainerRef);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPComponentSlotDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AXPComponentSlotDirective, "axp-component-slot", never, { "name": { "alias": "name"; "required": false; }; }, {}, never, never, false, never>;
+}

package/common/lib/layout/component-slot/component-slot.module.d.ts

@@ -0,0 +1,15 @@
+import { ModuleWithProviders } from '@angular/core';
+import { AXPComponentSlotModuleConfigs } from './component-slot.types';
+import * as i0 from "@angular/core";
+import * as i1 from "./component-slot.directive";
+export declare class AXPComponentSlotModule {
+    static forRoot(configs?: AXPComponentSlotModuleConfigs): ModuleWithProviders<AXPComponentSlotModule>;
+    static forChild(configs?: AXPComponentSlotModuleConfigs): ModuleWithProviders<AXPComponentSlotModule>;
+    /**
+     * @ignore
+     */
+    constructor(instances: any[]);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPComponentSlotModule, [{ optional: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPComponentSlotModule, [typeof i1.AXPComponentSlotDirective], never, [typeof i1.AXPComponentSlotDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXPComponentSlotModule>;
+}

package/common/lib/layout/component-slot/component-slot.types.d.ts

@@ -0,0 +1,14 @@
+import { Type } from "@angular/core";
+export interface AXPComponentSlotConfig {
+    name: string;
+    component?: Type<any>;
+    loadComponent?: () => Type<any>;
+    options?: {
+        [key: string]: unknown;
+    } | (() => {
+        [key: string]: unknown;
+    });
+}
+export interface AXPComponentSlotModuleConfigs {
+    [slotName: string]: AXPComponentSlotConfig[];
+}

package/common/lib/layout/component-slot/index.d.ts

@@ -0,0 +1,5 @@
+export * from './component-slot.types';
+export * from './component-slot.directive';
+export * from './component-slot-registery.service';
+export * from './component-slot-loader.service';
+export * from './component-slot.module';

package/common/lib/menu/index.d.ts

@@ -0,0 +1,2 @@
+export * from './menu.types';
+export * from './menu.loader';

package/common/lib/menu/menu.loader.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from "rxjs";
+import { InjectionToken } from "@angular/core";
+import { AXPMenuItem } from "./menu.types";
+export interface AXPMenuLoader {
+    getItems(depth?: number | null): Observable<AXPMenuItem[]>;
+    currentMenuItem(): AXPMenuItem | null;
+}
+export declare const AXP_MENU_LOADER: InjectionToken<AXPMenuLoader>;
+export declare class AXMenuLoaderDefault implements AXPMenuLoader {
+    private _items;
+    /**
+     * @ignore
+     */
+    constructor(items?: AXPMenuItem[]);
+    currentMenuItem(): AXPMenuItem | null;
+    getItems(depth?: number | null): Observable<AXPMenuItem[]>;
+}

package/common/lib/menu/menu.types.d.ts

@@ -0,0 +1,13 @@
+import { Action } from "@ngrx/store";
+export interface AXPMenuItem {
+    text: string;
+    type?: 'menu' | 'group';
+    name?: string;
+    icon?: string;
+    opened?: boolean;
+    children?: AXPMenuItem[];
+    parent?: AXPMenuItem;
+    path?: string;
+    command?: Action;
+    data?: any;
+}

package/common/lib/settings/index.d.ts

@@ -0,0 +1,3 @@
+export * from './settings.loader';
+export * from './settings.types';
+export * from './settings.service';

package/common/lib/settings/settings.loader.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "rxjs";
+import { AXPSetting } from "./settings.types";
+import { InjectionToken } from "@angular/core";
+export interface AXPSettingsLoader {
+    global$(): Observable<AXPSetting[]>;
+    user$(): Observable<AXPSetting[]>;
+}
+export declare const AXP_SETTINGS_LOADER: InjectionToken<AXPSettingsLoader>;

package/common/lib/settings/settings.service.d.ts

@@ -0,0 +1,9 @@
+import { AXPSetting } from "./settings.types";
+import * as i0 from "@angular/core";
+export declare class AXPSettingsService {
+    private readonly settingsLoader;
+    private settingsSubject;
+    readonly settings$: import("rxjs").Observable<AXPSetting[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPSettingsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPSettingsService>;
+}

package/common/lib/settings/settings.types.d.ts

@@ -0,0 +1,5 @@
+export interface AXPSetting {
+    key: string;
+    title: string;
+    value?: any;
+}

package/common/lib/shared/logo.types.d.ts

@@ -0,0 +1,19 @@
+import { Type } from '@angular/core';
+export interface AXPLogoConfig {
+}
+export declare class AXPTextLogoConfig implements AXPLogoConfig {
+    text: string;
+    constructor(text: string);
+}
+export declare class AXPImageUrlLogoConfig implements AXPLogoConfig {
+    url: string;
+    constructor(url: string);
+}
+export declare class AXPFontIconLogoConfig implements AXPLogoConfig {
+    iconClass: Type<any>;
+    constructor(iconClass: Type<any>);
+}
+export declare class AXPComponentLogoConfig implements AXPLogoConfig {
+    component: Type<any>;
+    constructor(component: Type<any>);
+}

package/common/lib/shared/state-persistence/index.d.ts

@@ -0,0 +1,3 @@
+export * from './state-persistence.reducers';
+export * from './state-persistence.actions';
+export * from './state-persistence.module';

package/common/lib/shared/state-persistence/state-persistence.actions.d.ts

@@ -0,0 +1 @@
+export declare const AXPLoadInitState: import("@ngrx/store").ActionCreator<"[App] Load State from Storage", () => import("@ngrx/store/src/models").TypedAction<"[App] Load State from Storage">>;

package/common/lib/shared/state-persistence/state-persistence.module.d.ts

@@ -0,0 +1,8 @@
+import { Store } from '@ngrx/store';
+import * as i0 from "@angular/core";
+export declare function initializeAppState(store: Store): () => void;
+export declare class AXPStatePersistenceModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPStatePersistenceModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AXPStatePersistenceModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AXPStatePersistenceModule>;
+}

package/common/lib/shared/state-persistence/state-persistence.reducers.d.ts

@@ -0,0 +1,3 @@
+import { ActionReducer, MetaReducer } from '@ngrx/store';
+export declare function syncStateReducer(reducer: ActionReducer<any>): ActionReducer<any>;
+export declare const metaReducers: MetaReducer[];

package/common/lib/store/common.actions.d.ts

@@ -0,0 +1,14 @@
+import { NavigationExtras } from "@angular/router";
+export declare const AXPNavigateAction: import("@ngrx/store").ActionCreator<"[Navigate] Action", (props: {
+    payload: {
+        commands: string | any[];
+        extras?: NavigationExtras;
+    };
+}) => {
+    payload: {
+        commands: string | any[];
+        extras?: NavigationExtras;
+    };
+} & import("@ngrx/store/src/models").TypedAction<"[Navigate] Action">>;
+export declare const AXPSignOutAction: import("@ngrx/store").ActionCreator<"[SignOut] Action", () => import("@ngrx/store/src/models").TypedAction<"[SignOut] Action">>;
+export declare const AXPSignInAction: import("@ngrx/store").ActionCreator<"[SignIn] Action", () => import("@ngrx/store/src/models").TypedAction<"[SignIn] Action">>;

package/common/lib/store/common.effects.d.ts

@@ -0,0 +1,11 @@
+import { Router } from "@angular/router";
+import { Actions } from "@ngrx/effects";
+import * as i0 from "@angular/core";
+export declare class AXPCommonEffects {
+    private actions$;
+    private router;
+    constructor(actions$: Actions, router: Router);
+    command$: import("rxjs").Observable<never> & import("@ngrx/effects").CreateEffectMetadata;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPCommonEffects, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPCommonEffects>;
+}

package/common/lib/store/index.d.ts

@@ -0,0 +1,2 @@
+export * from './common.actions';
+export * from './common.effects';

package/common/lib/utils/clipboard-service.d.ts

@@ -0,0 +1,7 @@
+import * as i0 from "@angular/core";
+export declare class AXPClipBoardService {
+    private toast;
+    copy(title: string, value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPClipBoardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPClipBoardService>;
+}

package/common/lib/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './clipboard-service';
+export * from './router-util.service';
+export * from './sticky.directive';

package/common/lib/utils/router-util.service.d.ts

@@ -0,0 +1,12 @@
+import { Router } from '@angular/router';
+import { AXPMenuItem } from '../menu';
+import * as i0 from "@angular/core";
+export declare class AXPRouteUtilityService {
+    private router;
+    private routeActiveCache;
+    constructor(router: Router);
+    isRouteActive(item: AXPMenuItem): boolean;
+    private clearRouteCache;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AXPRouteUtilityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AXPRouteUtilityService>;
+}