@inobeta/ui 18.0.1-build.1722007687

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@inobeta/ui" />
+export * from './public_api';

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@inobeta/ui",
+  "version": "18.0.1-build.1722007687",
+  "private": false,
+  "peerDependencies": {
+    "@angular/animations": "^18.x.x",
+    "@angular/cdk": "^18.x.x",
+    "@angular/common": "^18.x.x",
+    "@angular/compiler": "^18.x.x",
+    "@angular/core": "^18.x.x",
+    "@angular/forms": "^18.x.x",
+    "@angular/material": "^18.x.x",
+    "@angular/platform-browser": "^18.x.x",
+    "@angular/platform-browser-dynamic": "^18.x.x",
+    "@angular/router": "^18.x.x",
+    "@ngrx/effects": "^18.x.x",
+    "@ngrx/store": "^18.x.x",
+    "@ngrx/store-devtools": "^18.x.x",
+    "@ngx-translate/core": "^15.x.x",
+    "@ngx-translate/http-loader": "^8.x.x",
+    "jspdf": "^2.5.1",
+    "jspdf-autotable": "^3.8.1",
+    "jwt-decode": "^4.0.0",
+    "papaparse": "^5.3.1",
+    "rxjs": "^7.x.x",
+    "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz",
+    "zone.js": "~0.14.2"
+  },
+  "overrides": {
+    "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz"
+  },
+  "dependencies": {
+    "@ngrx/operators": "^18.0.0",
+    "tslib": "^2.4.0"
+  },
+  "exports": {
+    ".": {
+      "sass": "./_index.scss",
+      "types": "./index.d.ts",
+      "esm2022": "./esm2022/inobeta-ui.mjs",
+      "esm": "./esm2022/inobeta-ui.mjs",
+      "default": "./fesm2022/inobeta-ui.mjs"
+    },
+    "./package.json": {
+      "default": "./package.json"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/inobeta/ui.git"
+  },
+  "module": "fesm2022/inobeta-ui.mjs",
+  "typings": "index.d.ts",
+  "sideEffects": false
+}

package/public_api.d.ts

@@ -0,0 +1,16 @@
+export * from './src/app/inobeta-ui/core';
+export * from './src/app/inobeta-ui/http/index';
+export * from './src/app/inobeta-ui/hydration/index';
+export * from './src/app/inobeta-ui/storage/index';
+export * from './src/app/inobeta-ui/translate/index';
+export * from './src/app/inobeta-ui/ui/breadcrumb/index';
+export * from './src/app/inobeta-ui/ui/data-export/index';
+export * from './src/app/inobeta-ui/ui/forms/index';
+export * from './src/app/inobeta-ui/ui/kai-filter/index';
+export * from './src/app/inobeta-ui/ui/kai-table/index';
+export * from './src/app/inobeta-ui/ui/main-menu/index';
+export * from './src/app/inobeta-ui/ui/material-forms/index';
+export * from './src/app/inobeta-ui/ui/modal/index';
+export * from './src/app/inobeta-ui/ui/toast/index';
+export * from './src/app/inobeta-ui/ui/uploader/index';
+export * from './src/app/inobeta-ui/ui/views/index';

package/src/app/inobeta-ui/core/filter.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from "@angular/core";
+import * as i0 from "@angular/core";
+export declare class IbFilterPipe implements PipeTransform {
+    transform(items: string[], query: string): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbFilterPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<IbFilterPipe, "filterBy", true>;
+}

package/src/app/inobeta-ui/core/index.d.ts

@@ -0,0 +1 @@
+export * from "./filter.pipe";

package/src/app/inobeta-ui/http/auth/guard.service.d.ts

@@ -0,0 +1,96 @@
+import { ActivatedRouteSnapshot, Router } from "@angular/router";
+import { Store } from "@ngrx/store";
+import { Observable } from "rxjs";
+import { IbLoginService } from "./login.service";
+import { IbAPITokens, IbSession } from "./session.model";
+import * as i0 from "@angular/core";
+/**
+ * Guard routes based on user authentication.
+ *
+ * Usage:
+ * - Include the `IbAuthGuard` in the `canActivate` route guard to protect routes.
+ * - If the user is not authenticated, they will be redirected to the login page provided by the `ibHttpGUILoginUrl` token.
+ *
+ * Example:
+ * ```typescript
+ * const routes: Routes = [
+ *   {
+ *     path: 'dashboard',
+ *     component: DashboardComponent,
+ *     canActivate: [IbAuthGuard],
+ *   },
+ *   // ... other routes ...
+ * ];
+ * ```
+ */
+export declare class IbAuthGuard {
+    private router;
+    ibHttpGUILoginUrl: string;
+    store: Store<any>;
+    session$: Observable<IbSession<IbAPITokens> | null>;
+    constructor(router: Router, ibHttpGUILoginUrl: string);
+    canActivate(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbAuthGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IbAuthGuard>;
+}
+/**
+ * Guard routes based on user login status.
+ * The opposite of IbAuthGuard, the route will activate if a user is NOT authenticated
+ *
+ * Usage:
+ * - Include the `IbLoginGuard` in the `canActivate` route guard to protect routes.
+ * - If the user is authenticated, they will be redirected to a page provided by the `ibHttpGUIDashboardUrl` token
+ *
+ * Example:
+ * ```typescript
+ * const routes: Routes = [
+ *   {
+ *     path: 'login',
+ *     component: LoginComponent,
+ *     canActivate: [IbLoginGuard],
+ *   },
+ *   // ... other routes ...
+ * ];
+ * ```
+ */
+export declare class IbLoginGuard {
+    private router;
+    ibHttpGUIDashboardUrl: string;
+    store: Store<any>;
+    session$: Observable<IbSession<IbAPITokens> | null>;
+    path: string;
+    constructor(router: Router, ibHttpGUIDashboardUrl: string);
+    canActivate(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbLoginGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IbLoginGuard>;
+}
+/**
+ * Guard routes based on user roles.
+ *
+ * Usage:
+ * - Include the `IbRoleGuard` in the `canActivate` route guard to protect routes based on user roles.
+ * - Specify the required roles in the route's data property.
+ * - If the user is not granted access, they will be redirected to a page provided by the `ibHttpGUIDashboardUrl` token
+ *
+ * Example:
+ * ```typescript
+ * const routes: Routes = [
+ *   {
+ *     path: 'admin',
+ *     component: AdminComponent,
+ *     canActivate: [IbRoleGuard],
+ *     data: { roles: ['admin'] }
+ *   },
+ *   // ... other routes ...
+ * ];
+ * ```
+ */
+export declare class IbRoleGuard {
+    private router;
+    private login;
+    ibHttpGUIDashboardUrl: string;
+    constructor(router: Router, login: IbLoginService<IbAPITokens>, ibHttpGUIDashboardUrl: string);
+    canActivate(route: ActivatedRouteSnapshot): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbRoleGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IbRoleGuard>;
+}

package/src/app/inobeta-ui/http/auth/login.service.d.ts

@@ -0,0 +1,63 @@
+import { HttpClient } from "@angular/common/http";
+import { MatSnackBar } from "@angular/material/snack-bar";
+import { Router } from "@angular/router";
+import { Store } from "@ngrx/store";
+import { Observable } from "rxjs";
+import { IbAPITokens, IbUserLogin } from "./session.model";
+import * as i0 from "@angular/core";
+export declare class IbLoginService<T extends IbAPITokens | IbAPITokens> {
+    private httpClient;
+    private store;
+    private srvRouter;
+    private snackBar;
+    /** Login page path */
+    ibHttpGUILoginUrl: any;
+    /** API login endpoint */
+    ibHttpAPILoginUrl: any;
+    /** Authorizazion type. Either bearer token (JWT) or basic */
+    ibHttpAuthType: any;
+    /** Where to storage the user's access token */
+    ibHttpSessionStorageType: any;
+    /** Refresh access token API endpoint */
+    ibHttpAPIRefreshUrl: any;
+    /** Property name of additional data or claims within the JWT token */
+    ibHttpJWTClaimsField: any;
+    /** Property name of the user roles within the JWT claims field */
+    ibHttpJWTRolesField: any;
+    constructor(httpClient: HttpClient, store: Store, srvRouter: Router, snackBar: MatSnackBar, 
+    /** Login page path */
+    ibHttpGUILoginUrl: any, 
+    /** API login endpoint */
+    ibHttpAPILoginUrl: any, 
+    /** Authorizazion type. Either bearer token (JWT) or basic */
+    ibHttpAuthType: any, 
+    /** Where to storage the user's access token */
+    ibHttpSessionStorageType: any, 
+    /** Refresh access token API endpoint */
+    ibHttpAPIRefreshUrl: any, 
+    /** Property name of additional data or claims within the JWT token */
+    ibHttpJWTClaimsField: any, 
+    /** Property name of the user roles within the JWT claims field */
+    ibHttpJWTRolesField: any);
+    /**
+     * Attempts a login to the server by contacting the endpoint provided by the token {@link ibHttpAPILoginUrl}
+     */
+    login(user: IbUserLogin): Observable<T>;
+    /**
+     * Refresh a token by contacting the endpoint provided by the token {@link ibHttpAPIRefreshUrl}
+     */
+    refresh(token: string): Observable<IbAPITokens>;
+    /**
+     * Logout the user, clear the session, and navigate back to {@link ibHttpGUILoginUrl}
+     * @param makeSnack Whether to show a snackbar message when logging out
+     */
+    logout(makeSnack?: boolean): void;
+    /**
+     * Check whether the current user has at least one of the provided roles
+     * @param roles List of roles
+     * @returns true if the user has at least one of the provided roles
+     */
+    hasRoles(roles: string[]): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbLoginService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IbLoginService<any>>;
+}

package/src/app/inobeta-ui/http/auth/login.service.stub.spec.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from "rxjs";
+import { IbAPITokens, IbUserLogin } from "./session.model";
+import * as i0 from "@angular/core";
+export declare class IbLoginServiceStub<T extends IbAPITokens | IbAPITokens> {
+    login(u: IbUserLogin): Observable<T>;
+    logout(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbLoginServiceStub<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IbLoginServiceStub<any>>;
+}

package/src/app/inobeta-ui/http/auth/session.model.d.ts

@@ -0,0 +1,18 @@
+export declare class IbSession<T extends IbAPITokens | IbAPITokens> {
+    user: IbUserLogin;
+    valid: boolean;
+    serverData: T;
+}
+export declare class IbUserLogin {
+    email: string;
+    password: string;
+    rememberMe: boolean;
+}
+export declare enum IbAuthTypes {
+    BASIC_AUTH = 0,
+    JWT = 1
+}
+export interface IbAPITokens {
+    accessToken: string;
+    refreshToken: string;
+}

package/src/app/inobeta-ui/http/http/auth.interceptor.d.ts

@@ -0,0 +1,21 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from "@angular/common/http";
+import { Store } from "@ngrx/store";
+import { Observable } from "rxjs";
+import { IbToastNotification } from "../../ui/toast/toast.service";
+import { IbLoginService } from "../auth/login.service";
+import { IbAPITokens, IbAuthTypes, IbSession } from "../auth/session.model";
+import * as i0 from "@angular/core";
+export declare class IbAuthInterceptor implements HttpInterceptor {
+    private ibToast;
+    private login;
+    ibHttpEnableInterceptors: boolean;
+    ibHttpAPILoginUrl: string;
+    ibHttpToastOnLoginFailure: string;
+    ibHttpAuthType: IbAuthTypes;
+    store: Store<any>;
+    session$: Observable<IbSession<IbAPITokens> | null>;
+    constructor(ibToast: IbToastNotification, login: IbLoginService<IbAPITokens>, ibHttpEnableInterceptors: boolean, ibHttpAPILoginUrl: string, ibHttpToastOnLoginFailure: string, ibHttpAuthType: IbAuthTypes);
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbAuthInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IbAuthInterceptor>;
+}

package/src/app/inobeta-ui/http/http/error.interceptor.d.ts

@@ -0,0 +1,18 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from "@angular/common/http";
+import { TranslateService } from "@ngx-translate/core";
+import { Observable } from "rxjs";
+import { IbToastNotification } from "../../ui/toast/toast.service";
+import * as i0 from "@angular/core";
+export declare class IbErrorInterceptor implements HttpInterceptor {
+    private ibToast;
+    private translate;
+    ibHttpEnableInterceptors: boolean;
+    ibHttpToastOnGenericFailure: string;
+    ibHttpToastErrorField: string;
+    ibHttpToastOnStatusCode: any;
+    ibHttpToastErrorCode: string;
+    constructor(ibToast: IbToastNotification, translate: TranslateService, ibHttpEnableInterceptors: boolean, ibHttpToastOnGenericFailure: string, ibHttpToastErrorField: string, ibHttpToastOnStatusCode: any, ibHttpToastErrorCode: string);
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbErrorInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IbErrorInterceptor>;
+}

package/src/app/inobeta-ui/http/http/loader.interceptor.d.ts

@@ -0,0 +1,17 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from "@angular/common/http";
+import { Store } from "@ngrx/store";
+import { Observable } from "rxjs";
+import * as i0 from "@angular/core";
+export interface IbHttpRequestDefinition {
+    url: string;
+    method: string;
+}
+export declare class IbLoaderInterceptor implements HttpInterceptor {
+    private store;
+    ibHttpEnableInterceptors: boolean;
+    ibHttpUrlExcludedFromLoader: IbHttpRequestDefinition[];
+    constructor(store: Store, ibHttpEnableInterceptors: boolean, ibHttpUrlExcludedFromLoader: IbHttpRequestDefinition[]);
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbLoaderInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IbLoaderInterceptor>;
+}

package/src/app/inobeta-ui/http/http/loading-skeleton-container.component.d.ts

@@ -0,0 +1,13 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class IbLoadingSkeletonContainerComponent implements OnInit {
+    skeletons: {
+        width: string;
+        height: string;
+        className: string;
+    }[];
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbLoadingSkeletonContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IbLoadingSkeletonContainerComponent, "ib-loading-skeleton-container", never, { "skeletons": { "alias": "skeletons"; "required": false; }; }, {}, never, never, false, never>;
+}

package/src/app/inobeta-ui/http/http/loading-skeleton.component.d.ts

@@ -0,0 +1,12 @@
+import { ElementRef } from "@angular/core";
+import * as i0 from "@angular/core";
+export declare class IbLoadingSkeletonRectComponent {
+    private host;
+    width: string;
+    height: string;
+    className: string;
+    constructor(host: ElementRef<HTMLElement>);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbLoadingSkeletonRectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IbLoadingSkeletonRectComponent, "ib-loading-skeleton-rect", never, { "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "className": { "alias": "className"; "required": false; }; }, {}, never, never, false, never>;
+}

package/src/app/inobeta-ui/http/http/loading-skeleton.directive.d.ts

@@ -0,0 +1,27 @@
+import { TemplateRef, ViewContainerRef, OnDestroy, OnInit } from "@angular/core";
+import { Store } from "@ngrx/store";
+import { Observable, Subscription } from "rxjs";
+import * as i0 from "@angular/core";
+export declare class IbLoadingDirective implements OnInit, OnDestroy {
+    private tpl;
+    private vcr;
+    store: Store<any>;
+    isLoading$: Observable<boolean>;
+    isLoadingSpecificUrl$: Observable<boolean> | null;
+    config: {
+        size?: number;
+        width?: string;
+        height?: string;
+        className?: string;
+        endpoint?: {
+            url: string;
+            method: string;
+        } | null;
+    };
+    loadingSub?: Subscription;
+    constructor(tpl: TemplateRef<any>, vcr: ViewContainerRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbLoadingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IbLoadingDirective, "[ibLoading]", never, { "config": { "alias": "ibLoading"; "required": false; }; }, {}, never, never, false, never>;
+}

package/src/app/inobeta-ui/http/http/loading-skeleton.directive.stub.spec.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+export declare class IbLoadingStubDirective {
+    config: {
+        size: number;
+        width: string;
+        height: string;
+        className: string;
+        endpoint: any;
+    };
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbLoadingStubDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IbLoadingStubDirective, "[ibLoading]", never, { "config": { "alias": "ibLoading"; "required": false; }; }, {}, never, never, false, never>;
+}

package/src/app/inobeta-ui/http/http/messages.decorator.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Method decorator for displaying toast notifications and optionally navigating back after a CRUD operation.
+ *
+ * @param enableBackCall Indicates whether to navigate back after the operation.
+ * @param successMessage The success message to be displayed in the toast notification. (i18n)
+ * @param timeoutOnSave Time in milliseconds to wait before navigating back (if enabled).
+ * @returns MethodDecorator
+ *
+ * Usage example:
+ * ```typescript
+ * @ibCrudToast(true, 'Record saved successfully', 500)
+ * handleSave() {
+ *   // ... your save logic ...
+ *   return someObservable;
+ * }
+ * ```
+ */
+export declare function ibCrudToast(enableBackCall?: boolean, successMessage?: string, timeoutOnSave?: number): MethodDecorator;

package/src/app/inobeta-ui/http/http/role-check.directive.d.ts

@@ -0,0 +1,17 @@
+import { OnDestroy, OnInit, TemplateRef, ViewContainerRef } from "@angular/core";
+import { Subject } from "rxjs";
+import { IbLoginService } from "../auth/login.service";
+import { IbAPITokens } from "../auth/session.model";
+import * as i0 from "@angular/core";
+export declare class IbRoleCheckDirective implements OnInit, OnDestroy {
+    private tpl;
+    private vcr;
+    private login;
+    roles: string[];
+    destroy: Subject<void>;
+    constructor(tpl: TemplateRef<any>, vcr: ViewContainerRef, login: IbLoginService<IbAPITokens>);
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbRoleCheckDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IbRoleCheckDirective, "[ibRoleCheck]", never, { "roles": { "alias": "ibRoleCheck"; "required": false; }; }, {}, never, never, true, never>;
+}

package/src/app/inobeta-ui/http/http/spinner-loading.component.d.ts

@@ -0,0 +1,9 @@
+import { Store } from '@ngrx/store';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class IbSpinnerLoadingComponent {
+    store: Store<any>;
+    showLoading$: Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbSpinnerLoadingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IbSpinnerLoadingComponent, "ib-spinner-loading", never, {}, {}, never, never, false, never>;
+}

package/src/app/inobeta-ui/http/http/spinner-loading.stub.spec.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class SpinnerLoadingStubComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerLoadingStubComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpinnerLoadingStubComponent, "ib-spinner-loading", never, {}, {}, never, never, false, never>;
+}

package/src/app/inobeta-ui/http/http-test.module.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./http/spinner-loading.stub.spec";
+import * as i2 from "./http/loading-skeleton.directive.stub.spec";
+export declare class IbHttpTestModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbHttpTestModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IbHttpTestModule, [typeof i1.SpinnerLoadingStubComponent, typeof i2.IbLoadingStubDirective], never, [typeof i1.SpinnerLoadingStubComponent, typeof i2.IbLoadingStubDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IbHttpTestModule>;
+}

package/src/app/inobeta-ui/http/http.module.d.ts

@@ -0,0 +1,20 @@
+import { Injector, ModuleWithProviders } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "./http/spinner-loading.component";
+import * as i2 from "./http/loading-skeleton.directive";
+import * as i3 from "./http/loading-skeleton-container.component";
+import * as i4 from "./http/loading-skeleton.component";
+import * as i5 from "@ngx-translate/core";
+import * as i6 from "@angular/common";
+import * as i7 from "@angular/forms";
+import * as i8 from "../ui/toast/toast.module";
+import * as i9 from "../storage/storage.module";
+import * as i10 from "./http/role-check.directive";
+export declare class IbHttpModule {
+    static injector: Injector;
+    constructor(injector: Injector);
+    static forRoot(): ModuleWithProviders<IbHttpModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbHttpModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IbHttpModule, [typeof i1.IbSpinnerLoadingComponent, typeof i2.IbLoadingDirective, typeof i3.IbLoadingSkeletonContainerComponent, typeof i4.IbLoadingSkeletonRectComponent], [typeof i5.TranslateModule, typeof i6.CommonModule, typeof i7.ReactiveFormsModule, typeof i8.IbToastModule, typeof i9.IbStorageModule, typeof i10.IbRoleCheckDirective], [typeof i1.IbSpinnerLoadingComponent, typeof i2.IbLoadingDirective, typeof i3.IbLoadingSkeletonContainerComponent, typeof i4.IbLoadingSkeletonRectComponent, typeof i10.IbRoleCheckDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IbHttpModule>;
+}

package/src/app/inobeta-ui/http/index.d.ts

@@ -0,0 +1,23 @@
+export * from './auth/session.model';
+export * from './http/messages.decorator';
+export * from './http/spinner-loading.component';
+export * from './auth/guard.service';
+export * from './auth/login.service';
+export * from './store/loader/interfaces';
+export * from './store/session/interfaces';
+export * from './store/loader/actions';
+export * from './store/session/actions';
+export * from './store/loader/selectors';
+export * from './store/session/selectors';
+export * from './store/session/effects';
+export * from './store/loader/reducers';
+export * from './store/session/reducers';
+export * from './store/index';
+export * from './http/loading-skeleton.component';
+export * from './http/loading-skeleton-container.component';
+export * from './http/loading-skeleton.directive';
+export * from './http/role-check.directive';
+export * from './http.module';
+export * from './http-test.module';
+export * from './http/loading-skeleton.directive.stub.spec';
+export * from './http/spinner-loading.stub.spec';

package/src/app/inobeta-ui/http/store/index.d.ts

@@ -0,0 +1,10 @@
+import { ActionReducerMap } from '@ngrx/store';
+import { IbSessionEffects } from './session/effects';
+import { IbLoaderState } from './loader/interfaces';
+import { IbSessionState } from './session/interfaces';
+export interface IHttpStore {
+    session: IbSessionState;
+    loader: IbLoaderState;
+}
+export declare const ibHttpReducers: ActionReducerMap<IHttpStore>;
+export declare const ibHttpEffects: (typeof IbSessionEffects)[];

package/src/app/inobeta-ui/http/store/loader/actions.d.ts

@@ -0,0 +1,17 @@
+export declare const ibLoaderActions: {
+    incLoading: import("@ngrx/store").ActionCreator<"[Http/Loader] incLoading", (props: {
+        url: string;
+        method: string;
+    }) => {
+        url: string;
+        method: string;
+    } & import("@ngrx/store").Action<"[Http/Loader] incLoading">>;
+    decLoading: import("@ngrx/store").ActionCreator<"[Http/Loader] decLoading", (props: {
+        url: string;
+        method: string;
+    }) => {
+        url: string;
+        method: string;
+    } & import("@ngrx/store").Action<"[Http/Loader] decLoading">>;
+    skipShow: import("@ngrx/store").ActionCreator<"[Http/Loader] skipShow", () => import("@ngrx/store").Action<"[Http/Loader] skipShow">>;
+};

package/src/app/inobeta-ui/http/store/loader/interfaces.d.ts

@@ -0,0 +1,8 @@
+export interface IbLoaderState {
+    showLoading: boolean;
+    skipShow: boolean;
+    pendingRequestList: {
+        url: string;
+        method: string;
+    }[];
+}

package/src/app/inobeta-ui/http/store/loader/reducers.d.ts

@@ -0,0 +1,3 @@
+import { Action } from "@ngrx/store";
+import { IbLoaderState } from "./interfaces";
+export declare function loaderReducer(state: IbLoaderState, action: Action): IbLoaderState;

package/src/app/inobeta-ui/http/store/loader/selectors.d.ts

@@ -0,0 +1,5 @@
+export declare const ibSelectIsHttpLoading: import("@ngrx/store").MemoizedSelector<any, boolean, (s1: any) => boolean>;
+export declare const ibSelectIsHttpUrlLoading: (endpoint: {
+    url: string;
+    method: string;
+}) => import("@ngrx/store").MemoizedSelector<any, boolean, (s1: any) => boolean>;

package/src/app/inobeta-ui/http/store/session/actions.d.ts

@@ -0,0 +1,20 @@
+import { IbAPITokens, IbSession } from "../../auth/session.model";
+/**
+ * User session actions
+ */
+export declare const ibAuthActions: {
+    /**
+     * Note that the name might be confusing. This action should be dispatched as a login success, rather than a login attempt.
+     *
+     * Legacy: only stores a token in the storage. Does not call the `login()` function
+     */
+    login: import("@ngrx/store").ActionCreator<"[IbSession Service] Login", (props: {
+        activeSession: IbSession<IbAPITokens>;
+    }) => {
+        activeSession: IbSession<IbAPITokens>;
+    } & import("@ngrx/store").Action<"[IbSession Service] Login">>;
+    /** Dispatch and listen to this action to cleanup the user's session on logout */
+    logout: import("@ngrx/store").ActionCreator<"[IbSession Service] Logout", () => import("@ngrx/store").Action<"[IbSession Service] Logout">>;
+    /** Dispatch to start a timer and refresh the access token once expired */
+    refreshCycle: import("@ngrx/store").ActionCreator<"[IbSession Service] refreshCycle", () => import("@ngrx/store").Action<"[IbSession Service] refreshCycle">>;
+};

package/src/app/inobeta-ui/http/store/session/effects.d.ts

@@ -0,0 +1,16 @@
+import { IbStorageTypes } from "../../../storage/storage.service";
+import { IbLoginService } from "../../auth/login.service";
+import { IbAPITokens, IbSession } from "../../auth/session.model";
+import * as i0 from "@angular/core";
+export declare class IbSessionEffects {
+    private login;
+    ibHttpSessionStorageType: IbStorageTypes;
+    private actions$;
+    private store;
+    refreshCycle$: import("rxjs").Observable<import("@ngrx/store").Action<"[IbSession Service] Logout"> | import("@ngrx/store").Action<"[IbSession Service] refreshCycle"> | ({
+        activeSession: IbSession<IbAPITokens>;
+    } & import("@ngrx/store").Action<"[IbSession Service] Login">)> & import("@ngrx/effects").CreateEffectMetadata;
+    constructor(login: IbLoginService<IbAPITokens>, ibHttpSessionStorageType: IbStorageTypes);
+    static ɵfac: i0.ɵɵFactoryDeclaration<IbSessionEffects, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IbSessionEffects>;
+}

package/src/app/inobeta-ui/http/store/session/interfaces.d.ts

@@ -0,0 +1,4 @@
+import { IbAPITokens, IbSession } from "../../auth/session.model";
+export interface IbSessionState {
+    activeSession?: IbSession<IbAPITokens>;
+}

package/src/app/inobeta-ui/http/store/session/reducers.d.ts

@@ -0,0 +1,3 @@
+import { Action } from "@ngrx/store";
+import { IbSessionState } from "./interfaces";
+export declare function sessionReducer(state: IbSessionState, action: Action): IbSessionState;

package/src/app/inobeta-ui/http/store/session/selectors.d.ts

@@ -0,0 +1,4 @@
+import { IbAPITokens, IbSession } from '../../auth/session.model';
+export declare const ibSelectActiveSession: <T extends IbAPITokens | IbAPITokens>() => import("@ngrx/store").MemoizedSelector<any, IbSession<T>, (s1: any) => IbSession<T>>;
+export declare const ibSelectAccessTokenExp: import("@ngrx/store").MemoizedSelector<any, number, (s1: any) => number>;
+export declare const ibSelectDecodedData: <T>() => import("@ngrx/store").MemoizedSelector<any, T, (s1: any) => T>;