@smess/networking 1.0.3 → 1.0.5

package/dist/src/services/customer.service.test.js

@@ -0,0 +1,96 @@
+import { CustomerService } from './customer.service.js';
+import { NetworkingUIEventWrapped, AlertModel } from '../types/types.js';
+import { of, BehaviorSubject } from 'rxjs';
+describe('CustomerService', () => {
+    const config = {
+        baseUrl: 'https://api.example.com',
+        isProd: false,
+        clientId: 'test-client-id',
+        apiKey: 'test-api-key',
+    };
+    let service;
+    let $authToken;
+    beforeEach(() => {
+        $authToken = new BehaviorSubject(null);
+        service = new CustomerService(config, $authToken);
+    });
+    it('register success', async () => {
+        const payload = {
+            email: 'test@example.com',
+            password: 'pass',
+        };
+        const response = { data: { id: 1, email: 'test@example.com' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.register(payload).toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it('register error', async () => {
+        const payload = {
+            email: 'test@example.com',
+            password: 'pass',
+        };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.register(payload).toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it('getProfile success', async () => {
+        const response = { data: { id: 1, email: 'test@example.com' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.getProfile().toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it('getProfile error', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.getProfile().toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it('updateProfile success', async () => {
+        const payload = {
+            name: 'Test',
+            address: '123 Main St',
+            postal_code: '12345',
+            city: 'City',
+            state: null,
+            country: null,
+            contact_email: null,
+            phone_number: null,
+        };
+        const response = { data: { id: 1, name: 'Test' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.updateProfile(payload).toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it('updateProfile error', async () => {
+        const payload = {
+            name: 'Test',
+            address: '123 Main St',
+            postal_code: '12345',
+            city: 'City',
+            state: null,
+            country: null,
+            contact_email: null,
+            phone_number: null,
+        };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.updateProfile(payload).toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+});

package/dist/src/services/logger.service.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.$logger = exports.LoggerService = exports.LogLevel = void 0;
-var LogLevel;
+export var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
     LogLevel[LogLevel["INFO"] = 1] = "INFO";
     LogLevel[LogLevel["WARN"] = 2] = "WARN";
     LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
     LogLevel[LogLevel["NONE"] = 4] = "NONE";
-})(LogLevel || (exports.LogLevel = LogLevel = {}));
-class LoggerService {
+})(LogLevel || (LogLevel = {}));
+export class LoggerService {
     constructor() {
         this.currentLevel = LogLevel.DEBUG;
         this.logs = [];
@@ -92,6 +89,5 @@ class LoggerService {
         this.logs = [];
     }
 }
-exports.LoggerService = LoggerService;
 // Export singleton instance
-exports.$logger = new LoggerService();
+export const $logger = new LoggerService();

package/dist/src/services/logger.service.test.js

@@ -1,33 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const logger_service_1 = require("./logger.service");
+import { $logger, LogLevel } from './logger.service.js';
 describe('LoggerService', () => {
     beforeEach(() => {
-        logger_service_1.$logger.clearLogs();
-        logger_service_1.$logger.setLogLevel(logger_service_1.LogLevel.DEBUG);
+        $logger.clearLogs();
+        $logger.setLogLevel(LogLevel.DEBUG);
     });
     it('should log info', () => {
-        logger_service_1.$logger.info('info message', { foo: 1 }, 'test');
-        const logs = logger_service_1.$logger.getLogs();
-        expect(logs[0].level).toBe(logger_service_1.LogLevel.INFO);
+        $logger.info('info message', { foo: 1 }, 'test');
+        const logs = $logger.getLogs();
+        expect(logs[0].level).toBe(LogLevel.INFO);
         expect(logs[0].message).toBe('info message');
         expect(logs[0].data).toEqual({ foo: 1 });
         expect(logs[0].context).toBe('test');
     });
     it('should log warn and error', () => {
-        logger_service_1.$logger.warn('warn message');
-        logger_service_1.$logger.error('error message', { bar: 2 });
-        const logs = logger_service_1.$logger.getLogs();
-        expect(logs[0].level).toBe(logger_service_1.LogLevel.WARN);
-        expect(logs[1].level).toBe(logger_service_1.LogLevel.ERROR);
+        $logger.warn('warn message');
+        $logger.error('error message', { bar: 2 });
+        const logs = $logger.getLogs();
+        expect(logs[0].level).toBe(LogLevel.WARN);
+        expect(logs[1].level).toBe(LogLevel.ERROR);
         expect(logs[1].data).toEqual({ bar: 2 });
     });
     it('should respect log level', () => {
-        logger_service_1.$logger.setLogLevel(logger_service_1.LogLevel.ERROR);
-        logger_service_1.$logger.info('should not log');
-        logger_service_1.$logger.error('should log');
-        const logs = logger_service_1.$logger.getLogs();
+        $logger.setLogLevel(LogLevel.ERROR);
+        $logger.info('should not log');
+        $logger.error('should log');
+        const logs = $logger.getLogs();
         expect(logs.length).toBe(1);
-        expect(logs[0].level).toBe(logger_service_1.LogLevel.ERROR);
+        expect(logs[0].level).toBe(LogLevel.ERROR);
     });
 });

package/dist/src/services/order.service.d.ts

@@ -0,0 +1,60 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from '../types/types.js';
+import { SmessService } from './smess.service.js';
+import { BehaviorSubject, Observable } from 'rxjs';
+export type OrderTarget = 'order-list' | 'order-create' | 'order-delete' | 'order-get-draft' | 'order-update' | 'order-get';
+export interface CreateOrderRequest extends UpdateOrderRequest {
+}
+export interface UpdateOrderRequest {
+    external_id?: string;
+    order_date: string;
+    type?: string;
+    status?: string;
+    payment_status?: string;
+    delivery_note?: string;
+    delivery_fee?: number;
+    payment_method?: string;
+    payment_period?: string;
+    discount_in_percent?: number;
+    due_payment_amount?: number;
+    total_gst?: number;
+    total_exclude_gst?: number;
+    total_include_gst?: number;
+    order_items: OrderItemRequest[];
+}
+export interface OrderItemRequest {
+    product_name: string;
+    product_category: string;
+    supplier?: string;
+    supplier_code?: string;
+    supplier_item_name?: string;
+    unit: string;
+    quantity: number;
+    price_include_taxes: number;
+    vat_in_percent: number;
+    discount_in_percent?: number;
+    page_number?: number;
+    item_row_in_page?: number;
+}
+export declare class OrderProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, target: OrderTarget, $authToken: BehaviorSubject<string | null>);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string>;
+    getPath(...queryParams: unknown[]): string;
+}
+export declare class OrderService {
+    private readonly config;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, $authToken: BehaviorSubject<string | null>);
+    provider(target: OrderTarget): SmessService<OrderProvider>;
+    list(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    create(payload: CreateOrderRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    delete(id: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    getDraft(): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    update(id: string, payload: UpdateOrderRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    get(id: string): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+}

package/dist/src/services/order.service.js

@@ -0,0 +1,89 @@
+import { Accept, SMESSHeader, SmessService } from './smess.service.js';
+export class OrderProvider {
+    constructor(config, target, $authToken) {
+        this.config = config;
+        this.target = target;
+        this.$authToken = $authToken;
+    }
+    get baseURL() {
+        return this.config.version ? `${this.config.baseUrl}/${this.config.version}` : this.config.baseUrl;
+    }
+    get path() {
+        switch (this.target) {
+            case 'order-list':
+                return '/order/list';
+            case 'order-create':
+                return '/order/create';
+            case 'order-delete':
+                return '/order/${id}';
+            case 'order-get-draft':
+                return '/order/get-draft';
+            case 'order-update':
+            case 'order-get':
+            default:
+                return '/order/${id}';
+        }
+    }
+    get method() {
+        switch (this.target) {
+            case 'order-list':
+            case 'order-get':
+            case 'order-get-draft':
+                return 'GET';
+            case 'order-create':
+                return 'POST';
+            case 'order-update':
+                return 'PUT';
+            case 'order-delete':
+                return 'DELETE';
+            default:
+                return 'GET';
+        }
+    }
+    get headers() {
+        let headers = SmessService.getHeaders(Accept.V1, this.$authToken.value);
+        if (this.config.clientId) {
+            headers[SMESSHeader.ClientId] = this.config.clientId;
+        }
+        if (this.config.apiKey) {
+            headers[SMESSHeader.ApiKey] = this.config.apiKey;
+        }
+        return SmessService.filterHeaders(headers);
+    }
+    getPath(...queryParams) {
+        let definedPath = this.path;
+        const params = definedPath.match(/\$\{(.+?)\}/g);
+        params?.forEach((value, index) => {
+            definedPath = definedPath.replace(value, String(queryParams[index]));
+        });
+        return definedPath;
+    }
+}
+export class OrderService {
+    constructor(config, $authToken) {
+        this.config = config;
+        this.$authToken = $authToken;
+    }
+    provider(target) {
+        const targetWrapper = new OrderProvider(this.config, target, this.$authToken);
+        return new SmessService(targetWrapper);
+    }
+    list() {
+        return this.provider('order-list').request();
+    }
+    create(payload) {
+        return this.provider('order-create').request(payload);
+    }
+    delete(id) {
+        return this.provider('order-delete').request(null, undefined, id);
+    }
+    getDraft() {
+        return this.provider('order-get-draft').request();
+    }
+    update(id, payload) {
+        return this.provider('order-update').request(payload, undefined, id);
+    }
+    get(id) {
+        return this.provider('order-get').request(null, undefined, id);
+    }
+}

package/dist/src/services/order.service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/services/order.service.test.js

@@ -0,0 +1,135 @@
+import { OrderService } from './order.service.js';
+import { NetworkingUIEventWrapped, AlertModel } from '../types/types.js';
+import { of, BehaviorSubject } from 'rxjs';
+describe('OrderService', () => {
+    const config = {
+        baseUrl: 'https://api.example.com',
+        isProd: false,
+        clientId: 'test-client-id',
+        apiKey: 'test-api-key',
+    };
+    let service;
+    let $authToken;
+    beforeEach(() => {
+        $authToken = new BehaviorSubject(null);
+        service = new OrderService(config, $authToken);
+    });
+    it('list success', async () => {
+        const response = { data: [{ id: '1', status: 'draft' }] };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.list().toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it('list error', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.list().toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it('create success', async () => {
+        const payload = {
+            order_date: '2024-01-01',
+            order_items: [],
+        };
+        const response = { data: { id: '1', status: 'created' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.create(payload).toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it('create error', async () => {
+        const payload = {
+            order_date: '2024-01-01',
+            order_items: [],
+        };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.create(payload).toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it('delete success', async () => {
+        const response = { data: { id: '1', status: 'deleted' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.delete('1').toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it('delete error', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.delete('1').toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it('getDraft success', async () => {
+        const response = { data: { id: 'draft', status: 'draft' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.getDraft().toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it('getDraft error', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: () => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.getDraft().toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it('update success', async () => {
+        const payload = {
+            order_date: '2024-01-01',
+            order_items: [],
+        };
+        const response = { data: { id: '1', status: 'updated' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.update('1', payload).toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it('update error', async () => {
+        const payload = {
+            order_date: '2024-01-01',
+            order_items: [],
+        };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.update('1', payload).toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+    it('get success', async () => {
+        const response = { data: { id: '1', status: 'fetched' } };
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.succeeded(response)),
+        });
+        const result = await service.get('1').toPromise();
+        expect(result?.hasSuccess).toBe(true);
+        expect(result?.response).toEqual(response);
+    });
+    it('get error', async () => {
+        jest.spyOn(service, 'provider').mockReturnValue({
+            request: (_payload, _mockResponse, id) => of(NetworkingUIEventWrapped.failed(AlertModel.default())),
+        });
+        const result = await service.get('1').toPromise();
+        expect(result?.hasFailed).toBe(true);
+        expect(result?.alertModel).toBeInstanceOf(AlertModel);
+    });
+});

package/dist/src/services/product.service.d.ts

@@ -1,6 +1,6 @@
-import { BaseProvider } from '../core/base.provider';
-import { BaseServiceWrapper } from '../core/base.service.wrapper';
-import { NetworkingConfig } from '../types/types';
+import { BaseProvider } from '../core/base.provider.js';
+import { BaseServiceWrapper } from '../core/base.service.wrapper.js';
+import { NetworkingConfig } from '../types/types.js';
 export interface Product {
     id: number;
     name: string;
@@ -15,7 +15,7 @@ export declare class ProductProvider extends BaseProvider {
 export declare class ProductService extends BaseServiceWrapper<ProductProvider> {
     private config;
     constructor(config: NetworkingConfig, productId?: number, method?: string);
-    fetchProductById(id: number): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<Product>>;
-    fetchAllProducts(): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<Product[]>>;
-    createProduct(product: Omit<Product, 'id'>): import("rxjs").Observable<import("../types/types").NetworkingUIEventWrapped<Product>>;
+    fetchProductById(id: number): import("rxjs").Observable<import("../types/types.js").NetworkingUIEventWrapped<Product>>;
+    fetchAllProducts(): import("rxjs").Observable<import("../types/types.js").NetworkingUIEventWrapped<Product[]>>;
+    createProduct(product: Omit<Product, 'id'>): import("rxjs").Observable<import("../types/types.js").NetworkingUIEventWrapped<Product>>;
 }

package/dist/src/services/product.service.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProductService = exports.ProductProvider = void 0;
-const base_provider_1 = require("../core/base.provider");
-const base_service_wrapper_1 = require("../core/base.service.wrapper");
+import { BaseProvider } from '../core/base.provider.js';
+import { BaseServiceWrapper } from '../core/base.service.wrapper.js';
 // ProductProvider implements ProviderType for product endpoints
-class ProductProvider extends base_provider_1.BaseProvider {
+export class ProductProvider extends BaseProvider {
     constructor(config, { productId, method } = {}) {
         super({
             config,
@@ -15,9 +12,8 @@ class ProductProvider extends base_provider_1.BaseProvider {
         });
     }
 }
-exports.ProductProvider = ProductProvider;
 // ProductService provides high-level methods for product API
-class ProductService extends base_service_wrapper_1.BaseServiceWrapper {
+export class ProductService extends BaseServiceWrapper {
     constructor(config, productId, method) {
         super(new ProductProvider(config, { productId, method }));
         this.config = config;
@@ -38,7 +34,6 @@ class ProductService extends base_service_wrapper_1.BaseServiceWrapper {
         return this.request(product);
     }
 }
-exports.ProductService = ProductService;
 // Example usage:
 // setNetworkingConfig({ baseUrl: 'https://fakestoreapi.com', isProd: false });
 // const productService = new ProductService();

package/dist/src/services/product.service.test.js

@@ -1,9 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const product_service_1 = require("./product.service");
-const types_1 = require("../types/types");
-const rxjs_1 = require("rxjs");
-const base_service_wrapper_1 = require("../core/base.service.wrapper");
+import { ProductService } from './product.service.js';
+import { NetworkingUIEventWrapped } from '../types/types.js';
+import { of, throwError } from 'rxjs';
+import { BaseServiceWrapper } from '../core/base.service.wrapper.js';
 describe('ProductService', () => {
     const config = {
         baseUrl: 'https://jsonplaceholder.typicode.com',
@@ -14,37 +12,38 @@ describe('ProductService', () => {
     const product = { id: 1, name: 'Product', price: 10 };
     let requestSpy;
     beforeEach(() => {
-        requestSpy = jest.spyOn(base_service_wrapper_1.BaseServiceWrapper.prototype, 'request').mockImplementation(() => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded(product)));
+        requestSpy = jest.spyOn(BaseServiceWrapper.prototype, 'request').mockImplementation(() => of(NetworkingUIEventWrapped.succeeded(product)));
     });
     afterEach(() => {
         requestSpy.mockRestore();
     });
-    it('should fetch product by id', done => {
-        const service = new product_service_1.ProductService(config, 1);
-        service.fetchProductById(1).subscribe(result => {
+    it('should fetch product by id', (done) => {
+        const service = new ProductService(config, 1);
+        service.fetchProductById(1).subscribe((result) => {
             expect(result.response).toEqual(product);
             done();
         });
     });
-    it('should fetch all products', done => {
-        const service = new product_service_1.ProductService(config);
-        service.fetchAllProducts().subscribe(result => {
+    it('should fetch all products', (done) => {
+        const service = new ProductService(config);
+        service.fetchAllProducts().subscribe((result) => {
             expect(result.response).toEqual(product);
             done();
         });
     });
-    it('should create a product', done => {
-        const service = new product_service_1.ProductService(config);
-        service.createProduct({ name: 'New Product', price: 99.99 }).subscribe(result => {
+    it('should create a product', (done) => {
+        const service = new ProductService(config);
+        service.createProduct({ name: 'New Product', price: 99.99 }).subscribe((result) => {
             expect(result.response).toEqual(product);
             done();
         });
     });
-    it('request should handle error', done => {
-        requestSpy.mockImplementationOnce(() => (0, rxjs_1.throwError)(() => new Error('Test error')));
-        const service = new product_service_1.ProductService(config);
-        service.request('error').subscribe({
-            error: err => {
+    it('request should handle error', (done) => {
+        requestSpy.mockImplementationOnce(() => throwError(() => new Error('Test error')));
+        const service = new ProductService(config);
+        // Simulate error by calling a method that uses request
+        service.fetchProductById(1).subscribe({
+            error: (err) => {
                 expect(err).toBeInstanceOf(Error);
                 expect(err.message).toBe('Test error');
                 done();

package/dist/src/services/smess.service.d.ts

@@ -1,5 +1,5 @@
-import { HeaderType, NetworkingUIEventWrapped, ProviderType } from '../types/types';
-import { Observable } from '../utils/rxjs-import';
+import { ProviderType, NetworkingUIEventWrapped, HeaderType } from '../types/types.js';
+import { Observable } from '../utils/rxjs-import.js';
 export declare enum SMESSHeader {
     ContentType = "Content-Type",
     Authorization = "Authorization",
@@ -28,6 +28,7 @@ export declare class SmessService<T extends ProviderType> {
     private target;
     constructor(target: T);
     static getHeaders(version: Accept, authorization?: string | null, options?: HeaderType): Partial<Record<SMESSHeader, string | undefined>>;
+    static filterHeaders(headers: Partial<Record<SMESSHeader, string | undefined>>): Record<string, string>;
     private static commonHeaders;
     request<R = unknown>(request?: unknown, mockResponse?: R, ...queryParams: unknown[]): Observable<NetworkingUIEventWrapped<R>>;
     private transformAxiosError;