@esolve/ng-esolve-connect 0.46.2 → 0.47.0

package/index.d.ts

@@ -35,4 +35,5 @@ export * from './lib/enquiry';
 export * from './lib/wishlist';
 export * from './lib/suppliers';
 export * from './lib/coupons';
+export * from './lib/vouchers';
 export * from './lib/transactions';

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

@@ -1,9 +1,5 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { EsolveResult } from '../shared/esolve-result.model';
-import { EsolveErrorHandlerService } from '../shared/errors';
-import { EsolveResponseHandlerService } from '../shared/response';
-import { EsolveSessionService } from '../session/esolve-session.service';
 import { EsolveRegistrationData, EsolveRegistrationResult } from './registration';
 import { EsolveAddress, EsolveAddressResult, EsolveAddressPostData } from './address';
 import { EsolveChangePasswordResult, EsolveResetPasswordResult } from './password';
@@ -11,18 +7,17 @@ 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;
-    private http;
-    private sessionService;
-    private errorHandler;
-    private responseHandler;
+    private readonly config;
+    private readonly http;
+    private readonly sessionService;
+    private readonly errorHandler;
+    private readonly responseHandler;
     private _user_id;
     get user_id(): number;
     set user_id(value: number);
-    constructor(config: EsolveConfigService, http: HttpClient, sessionService: EsolveSessionService, errorHandler: EsolveErrorHandlerService, responseHandler: EsolveResponseHandlerService);
+    constructor();
     updateUserAccount(user_account_data: EsolveUserAccountData): Observable<EsolveUserAccountResult>;
     getUserAccount(): Observable<EsolveUserAccount>;
     deleteUserAccount(): Observable<EsolveResult>;

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

@@ -1,12 +1,9 @@
 import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
 import { Observable } from 'rxjs';
-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: EsolveConfigService, session: EsolveSessionService);
+    private readonly config;
+    private readonly session;
     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,16 +1,12 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../core';
-import { EsolveErrorHandlerService } from '../shared/errors/esolve-error-handler.service';
-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;
-    constructor(config: EsolveConfigService, http: HttpClient, session: EsolveSessionService, errorHandler: EsolveErrorHandlerService);
+    private readonly config;
+    private readonly http;
+    private readonly session;
+    private readonly errorHandler;
+    constructor();
     getAccessToken(email: string, password: string, anonymous?: boolean): Observable<EsolveAuthGetResponse>;
     getAnonymousSession(): Observable<EsolveAuthGetResponse>;
     autoLogin(): Promise<void>;

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

@@ -1,12 +1,9 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-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: EsolveConfigService, http: HttpClient);
+    private readonly config;
+    private readonly http;
     /**
      * Retrieves banners records from eSolve instance
      *

package/lib/cart/classes/esolve-cart-totals.model.d.ts

@@ -22,6 +22,10 @@ export declare class EsolveCartTotals {
      * Total discount of all the item in the cart
      */
     discount_total: number;
+    /**
+     * Total of all vouchers used
+     */
+    voucher_total: number;
     /**
      * Grand total of cart which includes discount and VAT (NOTE: shipping and insurance is not included)
      */
@@ -46,5 +50,9 @@ export declare class EsolveCartTotals {
     /**
      * Total discount of all the item in the cart
      */
-    discount_total?: number);
+    discount_total?: number, 
+    /**
+     * Total of all vouchers used
+     */
+    voucher_total?: number);
 }

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

@@ -1,22 +1,17 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../core';
-import { EsolveErrorHandlerService } from '../shared/errors/esolve-error-handler.service';
-import { EsolveResponseHandlerService } from '../shared/response';
-import { EsolveCouponsService } from '../coupons';
+import { EsolveTransactionType } from '../transactions';
 import { EsolveCartTotals, EsolveCheckoutResult, EsolveEmptyCartResult, EsolveTransactionAnalyticsData } from './classes';
 import { EsolveAdditionalWhere, EsolveCartItemResponse, EsolveCartSetItem, EsolveTimeSlotCheckout } from './interfaces';
 import { EsolveCart, EsolveCartSetAction } from './types';
-import { EsolveTransactionType } from '../transactions';
 import * as i0 from "@angular/core";
 export declare class EsolveCartService {
-    private config;
-    private http;
-    private errorHandler;
-    private responseHandler;
-    private coupons;
+    private readonly config;
+    private readonly http;
+    private readonly errorHandler;
+    private readonly responseHandler;
+    private readonly coupons;
+    private readonly vouchers;
     private _cached_tracking;
-    constructor(config: EsolveConfigService, http: HttpClient, errorHandler: EsolveErrorHandlerService, responseHandler: EsolveResponseHandlerService, coupons: EsolveCouponsService);
     /**
      * Retrieves the current cart
      *

package/lib/cart/interfaces/esolve-cart-totals-record.interface.d.ts

@@ -4,4 +4,6 @@ export interface EsolveCartTotalsRecord {
     total: string;
     vat: string;
     discount: string;
+    vouchers: string;
+    wallet: string;
 }

package/lib/cart/interfaces/esolve-checkout-body.interface.d.ts

@@ -0,0 +1,13 @@
+import { EsolveTransactionType } from '../../transactions';
+import { EsolveTimeSlotCheckout } from './esolve-time-slot-checkout.interface';
+export interface EsolveCheckoutBody {
+    type: EsolveTransactionType;
+    addresses_id: number;
+    shipping_id: number;
+    payment_method_id: number;
+    location_id: number;
+    comments: string;
+    tracking: number;
+    time_slot?: EsolveTimeSlotCheckout;
+    vouchers?: string[];
+}

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

@@ -7,3 +7,4 @@ export * from './esolve-cart-set-item.interface';
 export * from './esolve-cart-totals-record.interface';
 export * from './esolve-transaction-analytics-data-record.interface';
 export * from './esolve-time-slot-checkout.interface';
+export * from './esolve-checkout-body.interface';

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

@@ -1,13 +1,10 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-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: EsolveConfigService, http: HttpClient);
+    private readonly config;
+    private readonly http;
     /**
      * Retrieves the category tree from eSolve instance and coverts it to the correct format.
      */

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

@@ -13,12 +13,13 @@ export declare class EsolveConfigService implements EsolveConnectConfig {
     native: boolean;
     session_storage_key: string;
     coupon_storage_key: string;
+    voucher_storage_key: string;
     device_designation: string;
     legacy_cdn?: string;
     cdn?: string;
     ftg_cdn?: string;
     error_image_path?: string;
-    constructor(config: EsolveConnectConfig);
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<EsolveConfigService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<EsolveConfigService>;
 }

package/lib/core/esolve-connect-config.interface.d.ts

@@ -46,6 +46,10 @@ export interface EsolveConnectConfig {
      * Key for coupon local storage (Default is `_ng_eslv_coupons`)
      */
     coupon_storage_key?: string;
+    /**
+     * Key for voucher local storage (Default is `_ng_eslv_vouchers`)
+     */
+    voucher_storage_key?: string;
     /**
      * Indicates whether the implementation is a native app or a website. If it is a native
      * app, the `device_designation` is required for native app features to be enabled

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

@@ -1,21 +1,17 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../core';
-import { EsolveCookieService } from '../shared/cookie/esolve-cookie.service';
 import { EsolveCoupon } from './classes';
 import { EsolveCouponValidationError, EsolveCouponValidationResult } from './interfaces';
 import * as i0 from "@angular/core";
 export declare class EsolveCouponsService {
-    private platformId;
-    private config;
-    private http;
-    private cookieService;
+    private readonly is_browser;
+    private readonly http;
+    private readonly config;
+    private readonly cookieService;
     private storage_key;
-    private coupons_cache;
+    private cache;
     private applied;
     private validation_error;
-    private is_browser;
-    constructor(platformId: object, config: EsolveConfigService, http: HttpClient, cookieService: EsolveCookieService);
+    constructor();
     onValidationError(): Observable<EsolveCouponValidationError | undefined>;
     onApplied(): Observable<void>;
     validate(coupon_key: string): Observable<EsolveCouponValidationResult>;

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

@@ -1,16 +1,11 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-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: EsolveConfigService, http: HttpClient, errorHandler: EsolveErrorHandlerService, responseHandler: EsolveResponseHandlerService);
+    private readonly config;
+    private readonly http;
+    private readonly errorHandler;
+    private readonly responseHandler;
     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

@@ -1,16 +1,15 @@
-import { ElementRef, OnChanges } from '@angular/core';
-import { EsolveConfigService } from '../../core';
+import { OnChanges } from '@angular/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;
+    private readonly el;
+    private readonly config;
     src: string;
     private no_image;
     private error_image_path;
-    constructor(el: ElementRef<HTMLImageElement | HTMLSourceElement>, config: EsolveConfigService);
+    constructor();
     ngOnChanges(): void;
     onError(): void;
     init(): void;

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

@@ -1,12 +1,9 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../core';
 import { EsolveLocation } from './classes/esolve-location.model';
 import * as i0 from "@angular/core";
 export declare class EsolveLocationsService {
-    private config;
-    private http;
-    constructor(config: EsolveConfigService, http: HttpClient);
+    private readonly config;
+    private readonly http;
     /**
      * Retrieves a list of stock locations
      *

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

@@ -1,13 +1,10 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-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: EsolveConfigService, http: HttpClient);
+    private readonly config;
+    private readonly http;
     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,9 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../core';
 import { EsolveMenu } from './types';
 import * as i0 from "@angular/core";
 export declare class EsolveMenuService {
-    private config;
-    private http;
-    constructor(config: EsolveConfigService, http: HttpClient);
+    private readonly config;
+    private readonly http;
     getMenuTree(identifier: string): Observable<EsolveMenu>;
     private handleMenu;
     static ɵfac: i0.ɵɵFactoryDeclaration<EsolveMenuService, never>;

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

@@ -1,15 +1,12 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
 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: EsolveConfigService, http: HttpClient);
+    private readonly config;
+    private readonly http;
     getNewsArticle(identifier: string): Observable<EsolveNewsArticle>;
     getNewsArticles(options?: EsolveNewsArticleOptions): Observable<EsolveNewsArticleList>;
     getNewsGroups(enable_images?: boolean): Observable<EsolveNewsGroup[]>;

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

@@ -1,18 +1,13 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../core';
-import { EsolveErrorHandlerService } from '../shared/errors/esolve-error-handler.service';
 import { EsolveResult } from '../shared/esolve-result.model';
-import { EsolveResponseHandlerService } from '../shared/response';
 import { EsolvePaymentMethod, EsolvePaymentResult, EsolveVaultItem, EsolveVaultItemResult } from './classes';
 import { EsolveCardData, EsolvePaymentMethodOptions, EsolvePaymentRedirectLinks } from './interfaces';
 import * as i0 from "@angular/core";
 export declare class EsolvePaymentService {
-    private config;
-    private http;
-    private errorHandler;
-    private responseHandler;
-    constructor(config: EsolveConfigService, http: HttpClient, errorHandler: EsolveErrorHandlerService, responseHandler: EsolveResponseHandlerService);
+    private readonly config;
+    private readonly http;
+    private readonly errorHandler;
+    private readonly responseHandler;
     /**
      * Retrieves a list of payment methods.
      *

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

@@ -1,13 +1,10 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../core';
 import { EsolveRange } from './esolve-range.model';
 import { EsolveRangeOptions } from './esolve-range-options.interface';
 import * as i0 from "@angular/core";
 export declare class EsolveRangesService {
-    private config;
-    private http;
-    constructor(config: EsolveConfigService, http: HttpClient);
+    private readonly config;
+    private readonly http;
     getRange(id: number): Observable<EsolveRange>;
     getRangeFromSEF(sef_range: string): Observable<EsolveRange>;
     getRanges(options?: EsolveRangeOptions): Observable<EsolveRange[]>;

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

@@ -1,16 +1,12 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../core';
-import { EsolveErrorHandlerService } from '../shared/errors';
 import { EsolveResult } from '../shared/esolve-result.model';
-import { EsolveResponseHandlerService, EsolveResponseResult } from '../shared/response';
+import { EsolveResponseResult } from '../shared/response';
 import * as i0 from "@angular/core";
 export declare class EsolveSessionMetadataService {
-    private config;
-    private http;
-    private errorHandler;
-    private responseHandler;
-    constructor(config: EsolveConfigService, http: HttpClient, errorHandler: EsolveErrorHandlerService, responseHandler: EsolveResponseHandlerService);
+    private readonly config;
+    private readonly http;
+    private readonly errorHandler;
+    private readonly responseHandler;
     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,6 +1,4 @@
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../core';
-import { EsolveCookieService } from '../shared/cookie/esolve-cookie.service';
 import { EsolveSession } from './interfaces';
 import * as i0 from "@angular/core";
 interface SessionUpdateOptions {
@@ -8,21 +6,20 @@ interface SessionUpdateOptions {
     location_id?: number;
 }
 export declare class EsolveSessionService {
-    private platformId;
-    private config;
-    private cookieService;
+    private readonly is_browser;
+    private readonly config;
+    private readonly cookieService;
     private token$;
     private user_id$;
     private location_id$;
     private state_hash;
     private _session;
     private storage_key;
-    private is_browser;
     private timer_start;
     private timer_stop;
     private expire;
     private session_end;
-    constructor(platformId: object, config: EsolveConfigService, cookieService: EsolveCookieService);
+    constructor();
     private initSession;
     isValid(): boolean;
     getSession(): Observable<EsolveSession>;

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

@@ -1,15 +1,12 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../../core';
 import { EsolveAssetOptions } from './esolve-asset-options.interface';
 import { EsolveAsset } from './esolve-asset.model';
 import { EsolveAssetList } from './esolve-asset-list.type';
 import { EsolveMediaAssetOptions } from './esolve-media-asset-options.interface';
 import * as i0 from "@angular/core";
 export declare class EsolveAssetsService {
-    private config;
-    private http;
-    constructor(config: EsolveConfigService, http: HttpClient);
+    private readonly config;
+    private readonly http;
     getAsset(id: number): Observable<EsolveAsset>;
     getAssets(options?: EsolveAssetOptions): Observable<EsolveAssetList>;
     getMediaAssets(options: EsolveMediaAssetOptions): Observable<EsolveAssetList>;

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

@@ -1,12 +1,9 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../../core';
 import { EsolveGeocodeResult } from './esolve-geocode-result.model';
 import * as i0 from "@angular/core";
 export declare class EsolveGeocoderService {
-    private config;
-    private http;
-    constructor(config: EsolveConfigService, http: HttpClient);
+    private readonly config;
+    private readonly http;
     geocode(street_number: string, street: string, suburb: string, city: string, province: string, country: string, postal_code: string): Observable<EsolveGeocodeResult>;
     reverseGeocode(latitude: number, longitude: number): Observable<EsolveGeocodeResult>;
     private processGeocodeResult;

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

@@ -1,12 +1,10 @@
-import { Meta, Title } from '@angular/platform-browser';
-import { EsolveConfigService } from '../../core';
 import { EsolveSeoInfo } from './esolve-seo-info.model';
 import * as i0 from "@angular/core";
 export declare class EsolveSeoService {
-    private config;
-    private title;
-    private meta;
-    private dom;
+    private readonly config;
+    private readonly title;
+    private readonly meta;
+    private readonly dom;
     private title_prefix;
     private title_suffix;
     private title_separator;
@@ -14,7 +12,7 @@ export declare class EsolveSeoService {
     private default_seo_description;
     private default_seo_keywords;
     private default_seo_url;
-    constructor(config: EsolveConfigService, title: Title, meta: Meta);
+    constructor();
     /**
      * Sets SEO tags for page
      * @param seoInfo SEO object

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

@@ -1,14 +1,11 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../core';
 import { EsolveTransactionType } from '../transactions';
 import { EsolveShippingCost, EsolveShippingMethod, EsolveTimeSlotConfig } from './classes';
 import { EsolveShippingMethodOptions } from './interfaces';
 import * as i0 from "@angular/core";
 export declare class EsolveShippingService {
-    private config;
-    private http;
-    constructor(config: EsolveConfigService, http: HttpClient);
+    private readonly config;
+    private readonly http;
     /**
      * Retrieves a list of shipping methods
      *

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

@@ -1,13 +1,10 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../core';
 import { EsolveSpecial } from './esolve-special.model';
 import { EsolveSpecialOptions } from './esolve-special-options.interface';
 import * as i0 from "@angular/core";
 export declare class EsolveSpecialsService {
-    private config;
-    private http;
-    constructor(config: EsolveConfigService, http: HttpClient);
+    private readonly config;
+    private readonly http;
     getSpecial(specials_id: number): Observable<EsolveSpecial>;
     getSpecialFromIdentifier(identifier: string): Observable<EsolveSpecial>;
     getSpecials(options?: EsolveSpecialOptions): Observable<EsolveSpecial[]>;

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

@@ -1,6 +1,4 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../core';
 import { EsolveCustomFields } from '../shared/custom-fields';
 import { EsolveFilterList } from '../shared/filters';
 import { EsolveMediaStockItemList } from './types';
@@ -8,9 +6,8 @@ import { EsolveStockItemOptions, EsolveRecipeStockOptions, EsolveMediaStockItemO
 import { EsolveStockItem, EsolveStockItemList, EsolveRecipeStockItem, EsolveLinkedStockItem, EsolveStockImageCollection } from './classes';
 import * as i0 from "@angular/core";
 export declare class EsolveStockService<T extends EsolveCustomFields = EsolveCustomFields> {
-    private config;
-    private http;
-    constructor(config: EsolveConfigService, http: HttpClient);
+    private readonly config;
+    private readonly http;
     /**
      * Retrieves the stock record from the eSolve instance using the code.
      *

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

@@ -1,13 +1,10 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../core';
 import { EsolveSupplier } from './classes';
 import { EsolveSupplierOptions } from './interfaces';
 import * as i0 from "@angular/core";
 export declare class EsolveSuppliersService {
-    private config;
-    private http;
-    constructor(config: EsolveConfigService, http: HttpClient);
+    private readonly config;
+    private readonly http;
     getSuppliers(options?: EsolveSupplierOptions): Observable<EsolveSupplier[]>;
     private getSupplierRecords;
     private processSuppliers;

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

@@ -1,13 +1,10 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../core';
 import { EsolveTag } from './esolve-tag.model';
 import { EsolveTagOptions } from './esolve-tag-options.interface';
 import * as i0 from "@angular/core";
 export declare class EsolveTagsService {
-    private config;
-    private http;
-    constructor(config: EsolveConfigService, http: HttpClient);
+    private readonly config;
+    private readonly http;
     /**
      * Retrieves active topics from the list of topic ID's. Note that inactive or expired
      * topics will not be retrieved.

package/lib/topics/esolve-topic.service.d.ts

@@ -1,12 +1,9 @@
-import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { EsolveConfigService } from '../core';
 import { EsolveTopic } from './esolve-topic.model';
 import * as i0 from "@angular/core";
 export declare class EsolveTopicService {
-    private config;
-    private http;
-    constructor(config: EsolveConfigService, http: HttpClient);
+    private readonly config;
+    private readonly http;
     /**
      * Retrieves active topics from the list of topic ID's. Note that inactive or expired
      * topics will not be retrieved.