@esolve/ng-esolve-connect 0.38.1 → 0.40.0

package/index.d.ts

@@ -1,6 +1,6 @@
 export * from './lib/ng-esolve-connect.module';
-export * from './lib/esolve-connect.config';
-export * from './lib/esolve-connect-config.constant';
+export * from './lib/core';
+export * from './lib/images';
 export * from './lib/shared/esolve-list.model';
 export * from './lib/shared/esolve-result.model';
 export * from './lib/shared/esolve-url-target.type';

package/lib/account/esolve-account.service.d.ts

@@ -1,6 +1,5 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConnectConfig } from '../esolve-connect.config';
 import { EsolveResult } from '../shared/esolve-result.model';
 import { EsolveErrorHandlerService } from '../shared/errors';
 import { EsolveResponseHandlerService } from '../shared/response';
@@ -12,6 +11,7 @@ import { EsolveTransaction, EsolveTransactionOptions, EsolveTransactionList } fr
 import { EsolveUserAccount, EsolveUserAccountData, EsolveUserAccountResult, EsolveUserClientAccountBalances } from './user-account';
 import { EsolveAccountConfirmationResult } from './confirmation';
 import { EsolveLocationUpdateResult } from './location';
+import { EsolveConfigService } from '../core';
 import * as i0 from "@angular/core";
 export declare class EsolveAccountService {
     private config;
@@ -22,7 +22,7 @@ export declare class EsolveAccountService {
     private _user_id;
     get user_id(): number;
     set user_id(value: number);
-    constructor(config: EsolveConnectConfig, http: HttpClient, sessionService: EsolveSessionService, errorHandler: EsolveErrorHandlerService, responseHandler: EsolveResponseHandlerService);
+    constructor(config: EsolveConfigService, http: HttpClient, sessionService: EsolveSessionService, errorHandler: EsolveErrorHandlerService, responseHandler: EsolveResponseHandlerService);
     updateUserAccount(user_account_data: EsolveUserAccountData): Observable<EsolveUserAccountResult>;
     getUserAccount(): Observable<EsolveUserAccount>;
     deleteUserAccount(): Observable<EsolveResult>;

package/lib/account/password/esolve-forgot-password-response.interface.d.ts

@@ -1,4 +1,4 @@
-import { EsolveSessionData } from '../../session/esolve-session-data.interface';
+import { EsolveSessionData } from '../../session';
 import { EsolvePostResponseItem } from '../../shared/response';
 export interface EsolveForgotPasswordResponse extends EsolvePostResponseItem {
     esolve_id: number;

package/lib/account/registration/esolve-registration-post-response-item.interface.d.ts

@@ -1,4 +1,4 @@
-import { EsolveSessionData } from '../../session/esolve-session-data.interface';
+import { EsolveSessionData } from '../../session';
 import { EsolvePostResponseItem } from '../../shared/response';
 export interface EsolveRegistrationPostResponseItem extends EsolvePostResponseItem {
     esolve_id: number;

package/lib/auth/esolve-auth-interceptor.service.d.ts

@@ -1,12 +1,12 @@
 import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConnectConfig } from '../esolve-connect.config';
-import { EsolveSessionService } from '../session/esolve-session.service';
+import { EsolveSessionService } from '../session';
+import { EsolveConfigService } from '../core';
 import * as i0 from "@angular/core";
 export declare class EsolveAuthInterceptorService implements HttpInterceptor {
     private config;
     private session;
-    constructor(config: EsolveConnectConfig, session: EsolveSessionService);
+    constructor(config: EsolveConfigService, session: EsolveSessionService);
     intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<EsolveAuthInterceptorService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<EsolveAuthInterceptorService>;

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

@@ -1,26 +1,24 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConnectConfig } from '../esolve-connect.config';
-import { EsolveCookieService } from '../shared/cookie/esolve-cookie.service';
+import { EsolveConfigService } from '../core';
 import { EsolveErrorHandlerService } from '../shared/errors/esolve-error-handler.service';
-import { EsolveSessionService } from '../session/esolve-session.service';
-import { EsolveAuthGetResponse } from './esolve-auth-get-response.type';
+import { EsolveSessionService } from '../session';
+import { EsolveAuthGetResponse } from './types';
 import * as i0 from "@angular/core";
 export declare class EsolveAuthService {
     private config;
     private http;
     private session;
     private errorHandler;
-    private cookieService;
-    constructor(config: EsolveConnectConfig, http: HttpClient, session: EsolveSessionService, errorHandler: EsolveErrorHandlerService, cookieService: EsolveCookieService);
-    static preValidate(auth: EsolveAuthService): () => Promise<boolean>;
+    constructor(config: EsolveConfigService, http: HttpClient, session: EsolveSessionService, errorHandler: EsolveErrorHandlerService);
     getAccessToken(email: string, password: string, anonymous?: boolean): Observable<EsolveAuthGetResponse>;
+    getAnonymousSession(): Observable<EsolveAuthGetResponse>;
     autoLogin(): Promise<void>;
     login(email: string, password: string): Observable<number>;
     logout(): Promise<EsolveAuthGetResponse>;
     validateCachedTokens(): Promise<boolean>;
     private checkAccessToken;
-    private handleExpiration;
+    private restore;
     private handleAuthentication;
     private handleError;
     static ɵfac: i0.ɵɵFactoryDeclaration<EsolveAuthService, never>;

package/lib/auth/index.d.ts

@@ -1,3 +1,5 @@
 export * from './esolve-auth.service';
-export * from './esolve-auth-check-response.type';
-export * from './esolve-auth-get-response.type';
+export * from './esolve-auth-interceptor.service';
+export * from './types';
+export * from './interfaces';
+export * from './providers';

package/lib/auth/interfaces/esolve-auth-check-data.interface.d.ts

@@ -0,0 +1,4 @@
+import { EsolveAuthGetData } from './esolve-auth-get-data.interface';
+export interface EsolveAuthCheckData extends Partial<EsolveAuthGetData> {
+    key_okay: boolean;
+}

package/lib/auth/{esolve-auth-data.interface.d.ts → interfaces/esolve-auth-data.interface.d.ts}

@@ -1,5 +1,7 @@
 export interface EsolveAuthData {
     expires: number;
     expiry_time: number;
+    grace_period: number;
     user_id: number;
+    location_id: number;
 }

package/lib/auth/{esolve-auth-response.interface.d.ts → interfaces/esolve-auth-response.interface.d.ts}

@@ -1,4 +1,4 @@
-import { EsolveAuthResponseData } from './esolve-auth-response-data.type';
+import { EsolveAuthResponseData } from '../types';
 export interface EsolveAuthResponse<T> {
     service_type: string;
     type: string;

package/lib/auth/interfaces/esolve-login-post-response-item.interface.d.ts

@@ -0,0 +1,6 @@
+import { EsolvePostResponseItem } from '../../shared/response';
+import { EsolveSessionData } from '../../session';
+export interface EsolveLoginPostResponseItem extends EsolvePostResponseItem {
+    esolve_id: number;
+    session_data: EsolveSessionData;
+}

package/lib/auth/interfaces/index.d.ts

@@ -0,0 +1,5 @@
+export * from './esolve-auth-check-data.interface';
+export * from './esolve-auth-data.interface';
+export * from './esolve-auth-get-data.interface';
+export * from './esolve-auth-response.interface';
+export * from './esolve-login-post-response-item.interface';

package/lib/auth/providers/esolve-eurus-auto-login.provider.d.ts

@@ -0,0 +1,2 @@
+import { Provider } from '@angular/core';
+export declare const ESOLVE_EURUS_AUTO_LOGIN: Provider;

package/lib/auth/providers/index.d.ts

@@ -0,0 +1 @@
+export * from './esolve-eurus-auto-login.provider';

package/lib/auth/types/esolve-auth-check-response.type.d.ts

@@ -0,0 +1,2 @@
+import { EsolveAuthCheckData, EsolveAuthResponse } from '../interfaces';
+export type EsolveAuthCheckResponse = EsolveAuthResponse<EsolveAuthCheckData>;

package/lib/auth/types/esolve-auth-get-response.type.d.ts

@@ -0,0 +1,2 @@
+import { EsolveAuthGetData, EsolveAuthResponse } from '../interfaces';
+export type EsolveAuthGetResponse = EsolveAuthResponse<EsolveAuthGetData>;

package/lib/auth/types/esolve-auth-response-data.type.d.ts

@@ -0,0 +1,2 @@
+import { EsolveAuthData } from '../interfaces';
+export type EsolveAuthResponseData<T> = EsolveAuthData & T;

package/lib/auth/{esolve-auth-result.type.d.ts → types/esolve-auth-result.type.d.ts}

@@ -1,3 +1,3 @@
+import { EsolveAuthGetData } from '../interfaces';
 import { EsolveAuthResponseData } from './esolve-auth-response-data.type';
-import { EsolveAuthGetData } from './esolve-auth-get-data.interface';
 export type EsolveAuthResult = EsolveAuthResponseData<EsolveAuthGetData>;

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

@@ -0,0 +1,4 @@
+export * from './esolve-auth-check-response.type';
+export * from './esolve-auth-get-response.type';
+export * from './esolve-auth-response-data.type';
+export * from './esolve-auth-result.type';

package/lib/banners/esolve-banner.service.d.ts

@@ -1,12 +1,12 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConnectConfig } from '../esolve-connect.config';
+import { EsolveConfigService } from '../core';
 import { EsolveBanner } from './esolve-banner.model';
 import * as i0 from "@angular/core";
 export declare class EsolveBannerService {
     private config;
     private http;
-    constructor(config: EsolveConnectConfig, http: HttpClient);
+    constructor(config: EsolveConfigService, http: HttpClient);
     /**
      * Retrieves banners records from eSolve instance
      *

package/lib/cart/esolve-cart.service.d.ts

@@ -1,6 +1,6 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConnectConfig } from '../esolve-connect.config';
+import { EsolveConnectConfig } from '../core/esolve-connect.config';
 import { EsolveErrorHandlerService } from '../shared/errors/esolve-error-handler.service';
 import { EsolveResponseHandlerService } from '../shared/response';
 import { EsolveCouponsService } from '../coupons';

package/lib/category-tree/esolve-category-tree.service.d.ts

@@ -1,13 +1,13 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConnectConfig } from '../esolve-connect.config';
+import { EsolveConfigService } from '../core';
 import { EsolveCategoryTreeItem } from './esolve-category-tree-item.model';
 import { EsolveCategoryTreeItemOptions } from './esolve-category-tree-item-options.interface';
 import * as i0 from "@angular/core";
 export declare class EsolveCategoryTreeService {
     private config;
     private http;
-    constructor(config: EsolveConnectConfig, http: HttpClient);
+    constructor(config: EsolveConfigService, http: HttpClient);
     /**
      * Retrieves the category tree from eSolve instance and coverts it to the correct format.
      */

package/lib/core/esolve-config.service.d.ts

@@ -0,0 +1,22 @@
+import { EsolveConnectConfig } from './esolve-connect.config';
+import * as i0 from "@angular/core";
+export declare class EsolveConfigService implements EsolveConnectConfig {
+    api_url: string;
+    wsid: string;
+    title_prefix: string;
+    title_suffix: string;
+    title_separator: string;
+    default_seo_title: string;
+    default_seo_description: string;
+    default_seo_keywords: string;
+    native: boolean;
+    session_storage_key: string;
+    coupon_storage_key: string;
+    device_designation: string;
+    legacy_cdn?: string;
+    cdn?: string;
+    error_image_path?: string;
+    constructor(config: EsolveConnectConfig);
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsolveConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EsolveConfigService>;
+}

package/lib/{esolve-connect.config.d.ts → core/esolve-connect.config.d.ts}

@@ -35,9 +35,9 @@ export interface EsolveConnectConfig {
      */
     default_seo_keywords?: string;
     /**
-     * Key for user session local storage (Default is `ngEslvUserSession`)
+     * Key for user session local storage (Default is `_ng_eslv_token`)
      */
-    user_session_storage_key?: string;
+    session_storage_key?: string;
     /**
      * Key for coupon local storage (Default is `_ng_eslv_coupons`)
      */
@@ -52,4 +52,22 @@ export interface EsolveConnectConfig {
      * `web`. If none is provided, then the value is assumed to be `web`
      */
     device_designation?: string;
+    /**
+     * It is used to specify the URL of a legacy content delivery network (CDN) that may be
+     * used for serving static assets such as images, videos, and other media files. This property is
+     * optional and may not be used if the application does not require a legacy CDN.
+     * @deprecated
+     */
+    legacy_cdn?: string;
+    /**
+     * This property is used to specify the URL of a content delivery network (CDN)
+     * that may be used for serving static assets such as images, videos, and other media
+     * files. If this property is not provided, the application may not use a CDN.
+     */
+    cdn?: string;
+    /**
+     * Specifies the path to an error image that can be displayed in case of errors or failures in
+     * the application. If this property is not provided, `/assets/no_image.jpg` is used instead.
+     */
+    error_image_path?: string;
 }

package/lib/core/index.d.ts

@@ -0,0 +1,3 @@
+export * from './esolve-config.service';
+export * from './esolve-connect-config.constant';
+export * from './esolve-connect.config';

package/lib/coupons/esolve-coupons.service.d.ts

@@ -1,6 +1,6 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConnectConfig } from '../esolve-connect.config';
+import { EsolveConnectConfig } from '../core/esolve-connect.config';
 import { EsolveCookieService } from '../shared/cookie/esolve-cookie.service';
 import { EsolveCoupon } from './classes';
 import { EsolveCouponValidationError, EsolveCouponValidationResult } from './interfaces';

package/lib/enquiry/esolve-enquiry.service.d.ts

@@ -1,16 +1,16 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConnectConfig } from '../esolve-connect.config';
 import { EsolveErrorHandlerService } from '../shared/errors';
 import { EsolveResponseHandlerService } from '../shared/response';
 import { EsolveEnquiryResult } from './esolve-enquiry-result.model';
+import { EsolveConfigService } from '../core';
 import * as i0 from "@angular/core";
 export declare class EsolveEnquiryService {
     private config;
     private http;
     private errorHandler;
     private responseHandler;
-    constructor(config: EsolveConnectConfig, http: HttpClient, errorHandler: EsolveErrorHandlerService, responseHandler: EsolveResponseHandlerService);
+    constructor(config: EsolveConfigService, http: HttpClient, errorHandler: EsolveErrorHandlerService, responseHandler: EsolveResponseHandlerService);
     send(form_data: FormData): Observable<EsolveEnquiryResult>;
     static ɵfac: i0.ɵɵFactoryDeclaration<EsolveEnquiryService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<EsolveEnquiryService>;

package/lib/images/directives/cdn-src.directive.d.ts

@@ -0,0 +1,22 @@
+import { ElementRef, OnChanges } from '@angular/core';
+import { EsolveConfigService } from '../../core';
+import * as i0 from "@angular/core";
+/**
+ * An alternative to optimised images to load a new image
+ */
+export declare class EsolveCdnSrcDirective implements OnChanges {
+    private el;
+    private config;
+    src: string;
+    private no_image;
+    private error_image_path;
+    constructor(el: ElementRef<HTMLImageElement | HTMLSourceElement>, config: EsolveConfigService);
+    ngOnChanges(): void;
+    onError(): void;
+    init(): void;
+    private setSrc;
+    private setErrorImage;
+    private isImage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsolveCdnSrcDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EsolveCdnSrcDirective, "[eslvCdnSrc]", never, { "src": "eslvCdnSrc"; }, {}, never, never, true, never>;
+}

package/lib/images/directives/index.d.ts

@@ -0,0 +1 @@
+export * from './cdn-src.directive';

package/lib/images/esolve-image-loader.provider.d.ts

@@ -0,0 +1,2 @@
+import { Provider } from '@angular/core';
+export declare const ESOLVE_IMAGE_LOADER_PROVIDER: Provider;

package/lib/images/functions/index.d.ts

@@ -0,0 +1,3 @@
+export * from './process-image-src.function';
+export * from './is-esolve-cdn-path.function';
+export * from './is-legacy-esolve-cdn-path.function';

package/lib/images/functions/is-esolve-cdn-path.function.d.ts

@@ -0,0 +1 @@
+export declare function isEsolveCdnPath(path: string): boolean;

package/lib/images/functions/is-legacy-esolve-cdn-path.function.d.ts

@@ -0,0 +1 @@
+export declare function isLegacyEsolveCdnPath(path: string): boolean;

package/lib/images/functions/process-image-src.function.d.ts

@@ -0,0 +1 @@
+export declare function processEsolveImageSrc(src: string, cdn_url?: string, legacy_cdn_url?: string): string;

package/lib/images/index.d.ts

@@ -0,0 +1,3 @@
+export * from './esolve-image-loader.provider';
+export * from './directives';
+export * from './functions';

package/lib/locations/esolve-locations.service.d.ts

@@ -1,6 +1,6 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConnectConfig } from '../esolve-connect.config';
+import { EsolveConnectConfig } from '../core/esolve-connect.config';
 import { EsolveLocation } from './classes/esolve-location.model';
 import * as i0 from "@angular/core";
 export declare class EsolveLocationsService {

package/lib/manufacturers/esolve-manufacturers.service.d.ts

@@ -1,13 +1,13 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConnectConfig } from '../esolve-connect.config';
+import { EsolveConfigService } from '../core';
 import { EsolveManufacturer } from './esolve-manufacturer.model';
 import { EsolveManufacturerOptions } from './esolve-manufacturer-options.interface';
 import * as i0 from "@angular/core";
 export declare class EsolveManufacturersService {
     private config;
     private http;
-    constructor(config: EsolveConnectConfig, http: HttpClient);
+    constructor(config: EsolveConfigService, http: HttpClient);
     getManufacturer(id: number): Observable<EsolveManufacturer>;
     getManufacturerFromSEF(sef_manufacturer: string): Observable<EsolveManufacturer>;
     getManufacturers(options?: EsolveManufacturerOptions): Observable<EsolveManufacturer[]>;

package/lib/menu/esolve-menu.service.d.ts

@@ -1,12 +1,12 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConnectConfig } from '../esolve-connect.config';
+import { EsolveConfigService } from '../core';
 import { EsolveMenu } from './types';
 import * as i0 from "@angular/core";
 export declare class EsolveMenuService {
     private config;
     private http;
-    constructor(config: EsolveConnectConfig, http: HttpClient);
+    constructor(config: EsolveConfigService, http: HttpClient);
     getMenuTree(identifier: string): Observable<EsolveMenu>;
     private handleMenu;
     static ɵfac: i0.ɵɵFactoryDeclaration<EsolveMenuService, never>;

package/lib/news/esolve-news.service.d.ts

@@ -1,15 +1,15 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConnectConfig } from '../esolve-connect.config';
 import { EsolveNewsArticle } from './esolve-news-article.model';
 import { EsolveNewsGroup } from './esolve-news-group.model';
 import { EsolveNewsArticleList } from './esolve-news-article-list.model';
 import { EsolveNewsArticleOptions } from './esolve-news-article-options.interface';
+import { EsolveConfigService } from '../core';
 import * as i0 from "@angular/core";
 export declare class EsolveNewsService {
     private config;
     private http;
-    constructor(config: EsolveConnectConfig, http: HttpClient);
+    constructor(config: EsolveConfigService, http: HttpClient);
     getNewsArticle(identifier: string): Observable<EsolveNewsArticle>;
     getNewsArticles(options?: EsolveNewsArticleOptions): Observable<EsolveNewsArticleList>;
     getNewsGroups(enable_images?: boolean): Observable<EsolveNewsGroup[]>;

package/lib/ng-esolve-connect.module.d.ts

@@ -1,10 +1,10 @@
 import { ModuleWithProviders } from '@angular/core';
-import { EsolveConnectConfig } from './esolve-connect.config';
+import { EsolveConnectConfig } from './core';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common";
 import * as i2 from "@angular/common/http";
 export declare class NgEsolveConnectModule {
-    static forRoot(config: EsolveConnectConfig): ModuleWithProviders<NgEsolveConnectModule>;
+    static forRoot(config: EsolveConnectConfig, auto_login?: boolean): ModuleWithProviders<NgEsolveConnectModule>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgEsolveConnectModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<NgEsolveConnectModule, never, [typeof i1.CommonModule, typeof i2.HttpClientModule], never>;
     static ɵinj: i0.ɵɵInjectorDeclaration<NgEsolveConnectModule>;

package/lib/payment/esolve-payment.service.d.ts

@@ -1,6 +1,6 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConnectConfig } from '../esolve-connect.config';
+import { EsolveConnectConfig } from '../core/esolve-connect.config';
 import { EsolveErrorHandlerService } from '../shared/errors/esolve-error-handler.service';
 import { EsolveResult } from '../shared/esolve-result.model';
 import { EsolveResponseHandlerService } from '../shared/response';

package/lib/ranges/esolve-ranges.service.d.ts

@@ -1,6 +1,6 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConnectConfig } from '../esolve-connect.config';
+import { EsolveConnectConfig } from '../core/esolve-connect.config';
 import { EsolveRange } from './esolve-range.model';
 import { EsolveRangeOptions } from './esolve-range-options.interface';
 import * as i0 from "@angular/core";

package/lib/session/esolve-session-metadata.service.d.ts

@@ -1,16 +1,16 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveResponseHandlerService, EsolveResponseResult } from '../shared/response';
+import { EsolveConfigService } from '../core';
 import { EsolveErrorHandlerService } from '../shared/errors';
 import { EsolveResult } from '../shared/esolve-result.model';
-import { EsolveConnectConfig } from '../esolve-connect.config';
+import { EsolveResponseHandlerService, EsolveResponseResult } from '../shared/response';
 import * as i0 from "@angular/core";
 export declare class EsolveSessionMetadataService {
     private config;
     private http;
     private errorHandler;
     private responseHandler;
-    constructor(config: EsolveConnectConfig, http: HttpClient, errorHandler: EsolveErrorHandlerService, responseHandler: EsolveResponseHandlerService);
+    constructor(config: EsolveConfigService, http: HttpClient, errorHandler: EsolveErrorHandlerService, responseHandler: EsolveResponseHandlerService);
     set(type: string, metadata: any): Observable<EsolveResponseResult>;
     get<T>(type: string): Observable<T>;
     delete(type: string): Observable<EsolveResult>;

package/lib/session/esolve-session.service.d.ts

@@ -1,7 +1,7 @@
 import { Observable } from 'rxjs';
+import { EsolveConfigService } from '../core';
 import { EsolveCookieService } from '../shared/cookie/esolve-cookie.service';
-import { EsolveConnectConfig } from '../esolve-connect.config';
-import { EsolveSession } from './esolve-session.model';
+import { EsolveSession } from './interfaces';
 import * as i0 from "@angular/core";
 interface SessionUpdateOptions {
     user_id?: number;
@@ -11,24 +11,45 @@ export declare class EsolveSessionService {
     private platformId;
     private config;
     private cookieService;
-    session: Observable<EsolveSession>;
+    private token$;
+    private user_id$;
+    private location_id$;
+    private state_hash;
     private _session;
-    private key_expiration_timer;
     private storage_key;
     private is_browser;
-    get currentSession(): EsolveSession;
-    constructor(platformId: object, config: EsolveConnectConfig, cookieService: EsolveCookieService);
-    clearTimer(): void;
-    getCachedSession(): EsolveSession | null;
-    resetSessionCache(): void;
-    restore(expirationCallback: (session?: EsolveSession) => void, invalidSessionCallback: () => void): void;
-    handleSession(user_id: number, location_id: number, key: string, expiry_time: number, expires: number, expirationCallback: () => void): void;
-    handleUpdateSession({ user_id, location_id }: SessionUpdateOptions, callback?: () => void): void;
+    private timer_start;
+    private timer_stop;
+    private expire;
+    private session_end;
+    constructor(platformId: object, config: EsolveConfigService, cookieService: EsolveCookieService);
+    private initSession;
+    isValid(): boolean;
+    getSession(): Observable<EsolveSession>;
+    getSessionValue(): EsolveSession;
+    onSessionEnd(): Observable<void>;
+    onExpire(): Observable<void>;
+    expireSession(): void;
+    getToken(): string;
+    onTokenUpdate(): Observable<string>;
+    updateToken(token: string): void;
+    getUserId(): number;
+    onUserIdUpdate(): Observable<number>;
+    updateUserId(user_id: number): void;
+    getLocationId(): number;
+    onLocationIdUpdate(): Observable<number>;
+    updateLocationId(location_id: number): void;
+    getStateHash(): string;
+    stopTimer(): void;
+    startTimer(time: number | Date): void;
+    getCachedSession(): string | null;
+    reset(): void;
+    handleSession(session: EsolveSession, expiry_date_unix: number, grace_unix: number): void;
+    handleUpdateSession({ user_id, location_id, }: SessionUpdateOptions): void;
     private setStorageKey;
-    private startTimer;
-    private getBackup;
-    private setBackup;
-    private removeBackup;
+    private getCache;
+    private setCache;
+    private removeCache;
     static ɵfac: i0.ɵɵFactoryDeclaration<EsolveSessionService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<EsolveSessionService>;
 }

package/lib/session/index.d.ts

@@ -1,5 +1,3 @@
-export * from './esolve-session.model';
-export * from './esolve-session-data.interface';
-export * from './esolve-stored-session.interface';
 export * from './esolve-session.service';
 export * from './esolve-session-metadata.service';
+export * from './interfaces';

package/lib/session/interfaces/esolve-session.interface.d.ts

@@ -0,0 +1,5 @@
+export interface EsolveSession {
+    token: string;
+    user_id: number;
+    location_id: number;
+}

package/lib/session/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from './esolve-session-data.interface';
+export * from './esolve-session.interface';

package/lib/shared/assets/esolve-assets.service.d.ts

@@ -1,6 +1,6 @@
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConnectConfig } from '../../esolve-connect.config';
+import { EsolveConnectConfig } from '../../core/esolve-connect.config';
 import { EsolveAssetOptions } from './esolve-asset-options.interface';
 import { EsolveAsset } from './esolve-asset.model';
 import { EsolveAssetList } from './esolve-asset-list.type';

package/lib/shared/cookie/esolve-cookie.service.d.ts

@@ -1,36 +1,12 @@
-import { Request, Response } from 'express';
-import { CookieService } from 'ngx-cookie-service';
+import { SsrCookieService } from 'ngx-cookie-service-ssr';
 import * as i0 from "@angular/core";
 export declare class EsolveCookieService {
-    private ngxCookies;
-    private platformId;
-    private request;
-    private response;
-    private is_browser;
-    constructor(ngxCookies: CookieService, platformId: object, request: Request, response: Response);
+    private cookieService;
+    constructor(cookieService: SsrCookieService);
     check(name: string): boolean;
     get(name: string): string;
     set(name: string, value: string, expires?: Date, path?: string, domain?: string, secure?: boolean): void;
     delete(name: string, path?: string, domain?: string, secure?: boolean): void;
-    /**
-     * Get cookie Regular Expression
-     *
-     * @param name Cookie name
-     * @returns property RegExp
-     *
-     * @link https://github.com/stevermeister/ngx-cookie-service/blob/bcb6ac203487c487fcd126896bffaa14981c709c/projects/ngx-cookie-service/src/lib/cookie.service.ts#L31
-     */
-    private getCookieRegExp;
-    /**
-     * Gets the unencoded version of an encoded component of a Uniform Resource Identifier (URI).
-     *
-     * @param encodedURIComponent A value representing an encoded URI component.
-     *
-     * @returns The unencoded version of an encoded component of a Uniform Resource Identifier (URI).
-     *
-     * @link https://github.com/stevermeister/ngx-cookie-service/blob/bcb6ac203487c487fcd126896bffaa14981c709c/projects/ngx-cookie-service/src/lib/cookie.service.ts#L47
-     */
-    private safeDecodeURIComponent;
-    static ɵfac: i0.ɵɵFactoryDeclaration<EsolveCookieService, [null, null, { optional: true; }, { optional: true; }]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EsolveCookieService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<EsolveCookieService>;
 }