@smess/networking 1.0.1

package/dist/services/smess.service.test.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const smess_service_1 = require("./smess.service");
+const types_1 = require("../types/types");
+const rxjs_1 = require("rxjs");
+describe('SmessService', () => {
+    const provider = {
+        baseURL: 'https://api.example.com',
+        path: '/resource',
+        method: 'GET',
+        headers: {},
+        getPath: () => '/resource',
+    };
+    it('should return succeeded for GET', done => {
+        const service = new smess_service_1.SmessService(provider);
+        service['httpService'] = {
+            get: jest.fn(() => (0, rxjs_1.of)({ data: { foo: 'bar' } })),
+            post: jest.fn(),
+            patch: jest.fn(),
+            put: jest.fn(),
+            request: jest.fn(),
+            interceptors: { response: { use: jest.fn() } },
+        };
+        service.request().subscribe(result => {
+            expect(result).toBeInstanceOf(types_1.NetworkingUIEventWrapped);
+            expect(result.response).toEqual({ foo: 'bar' });
+            done();
+        });
+    });
+    it('should return succeeded for POST', done => {
+        const postProvider = Object.assign(Object.assign({}, provider), { method: 'POST' });
+        const service = new smess_service_1.SmessService(postProvider);
+        service['httpService'] = {
+            get: jest.fn(),
+            post: jest.fn(() => (0, rxjs_1.of)({ data: { foo: 'baz' } })),
+            patch: jest.fn(),
+            put: jest.fn(),
+            request: jest.fn(),
+            interceptors: { response: { use: jest.fn() } },
+        };
+        service.request({ some: 'data' }).subscribe(result => {
+            expect(result.response).toEqual({ foo: 'baz' });
+            done();
+        });
+    });
+    it('should handle error', done => {
+        const service = new smess_service_1.SmessService(provider);
+        service['httpService'] = {
+            get: jest.fn(() => (0, rxjs_1.throwError)(() => new Error('Test error'))),
+            post: jest.fn(),
+            patch: jest.fn(),
+            put: jest.fn(),
+            request: jest.fn(),
+            interceptors: { response: { use: jest.fn() } },
+        };
+        service.request().subscribe(result => {
+            var _a;
+            expect(result).toBeInstanceOf(types_1.NetworkingUIEventWrapped);
+            expect(result.hasFailed).toBe(true);
+            expect(result.alertModel).toBeTruthy();
+            expect((_a = result.alertModel) === null || _a === void 0 ? void 0 : _a.message).toBe('Test error');
+            done();
+        });
+    });
+    it('should return mock response if provided', done => {
+        const service = new smess_service_1.SmessService(provider);
+        service['httpService'] = {
+            get: jest.fn(() => (0, rxjs_1.throwError)(() => new Error('Test error'))),
+            post: jest.fn(),
+            patch: jest.fn(),
+            put: jest.fn(),
+            request: jest.fn(),
+            interceptors: { response: { use: jest.fn() } },
+        };
+        service.request(undefined, { foo: 'mock' }).subscribe(result => {
+            expect(result.response).toEqual({ foo: 'mock' });
+            done();
+        });
+    });
+});

package/dist/src/core/axios.d.ts

@@ -0,0 +1,51 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from '../utils/networking-import';
+import type { AxiosInterceptorManager } from 'axios';
+import { AxiosObservable } from './axios.observable';
+export interface Axiosable {
+    request<T = unknown>(config: AxiosRequestConfig): AxiosObservable<T>;
+    get<T = unknown>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    head<T = unknown>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    post<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): AxiosObservable<T>;
+    put<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): AxiosObservable<T>;
+    patch<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): AxiosObservable<T>;
+    delete<T = unknown>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+}
+declare class Axios implements Axiosable {
+    private axiosInstance;
+    static defaults: Omit<import("axios").AxiosDefaults<any>, "headers"> & {
+        headers: import("axios").HeadersDefaults & {
+            [key: string]: import("axios").AxiosHeaderValue;
+        };
+    };
+    static interceptors: {
+        request: AxiosInterceptorManager<import("axios").InternalAxiosRequestConfig>;
+        response: AxiosInterceptorManager<AxiosResponse>;
+    };
+    constructor(axiosInstance: AxiosInstance);
+    get defaults(): Omit<import("axios").AxiosDefaults<any>, "headers"> & {
+        headers: import("axios").HeadersDefaults & {
+            [key: string]: import("axios").AxiosHeaderValue;
+        };
+    };
+    get interceptors(): {
+        request: AxiosInterceptorManager<import("axios").InternalAxiosRequestConfig>;
+        response: AxiosInterceptorManager<AxiosResponse>;
+    };
+    static request<T = any>(config: AxiosRequestConfig): AxiosObservable<T>;
+    static get<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static patch<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static delete<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static head<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static create(config: AxiosRequestConfig): Axios;
+    request<T = any>(config: AxiosRequestConfig): AxiosObservable<T>;
+    get<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    head<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    patch<T = any>(url: string, data?: any, config?: AxiosRequestConfig): AxiosObservable<T>;
+    delete<T = any>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+}
+export default Axios;
+export { Axios };

package/dist/src/core/axios.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Axios = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any -- Required for axios compatibility */
+const networking_import_1 = require("../utils/networking-import");
+const axios_observable_1 = require("./axios.observable");
+class Axios {
+    constructor(axiosInstance) {
+        this.axiosInstance = axiosInstance;
+    }
+    get defaults() {
+        return this.axiosInstance.defaults;
+    }
+    get interceptors() {
+        return this.axiosInstance.interceptors;
+    }
+    // ----- Static Methods -----
+    static request(config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.request, [config]);
+    }
+    static get(url, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.get, [url, config]);
+    }
+    static post(url, data, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.post, [url, data, config]);
+    }
+    static put(url, data, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.put, [url, data, config]);
+    }
+    static patch(url, data, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.patch, [url, data, config]);
+    }
+    static delete(url, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.delete, [url, config]);
+    }
+    static head(url, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.head, [url, config]);
+    }
+    static create(config) {
+        return new Axios(networking_import_1.axios.create(config));
+    }
+    // ----- Instance Methods -----
+    request(config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.request, [config]);
+    }
+    get(url, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.get, [url, config]);
+    }
+    head(url, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.head, [url, config]);
+    }
+    post(url, data, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.post, [url, data, config]);
+    }
+    put(url, data, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.put, [url, data, config]);
+    }
+    patch(url, data, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.patch, [url, data, config]);
+    }
+    delete(url, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.delete, [url, config]);
+    }
+}
+exports.Axios = Axios;
+Axios.defaults = networking_import_1.axios.defaults;
+Axios.interceptors = networking_import_1.axios.interceptors;
+exports.default = Axios;

package/dist/src/core/axios.observable.d.ts

@@ -0,0 +1,11 @@
+import { AxiosResponse } from '../utils/networking-import';
+import type { AxiosPromise } from 'axios';
+import { Observable } from '../utils/rxjs-import';
+export type AxiosObservable<T> = Observable<AxiosResponse<T>>;
+interface ObservableOptions {
+    retry?: number;
+    timeoutMs?: number;
+    cache?: boolean;
+}
+export declare function createObservable<T>(promiseFactory: (...args: any[]) => AxiosPromise<T>, args: any[], options?: ObservableOptions): AxiosObservable<T>;
+export {};

package/dist/src/core/axios.observable.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createObservable = createObservable;
+/* eslint-disable @typescript-eslint/no-explicit-any -- Required for axios compatibility */
+const networking_import_1 = require("../utils/networking-import");
+const rxjs_import_1 = require("../utils/rxjs-import");
+const logger_service_1 = require("../services/logger.service");
+function createObservable(promiseFactory, args, options = {}) {
+    let config = args[args.length - 1];
+    if (config && typeof config === 'object' && !Array.isArray(config)) {
+        config = Object.assign({}, config);
+    }
+    else {
+        config = {};
+        args.push(config);
+    }
+    let cancelSource = null;
+    const hasCancelToken = !!config.cancelToken;
+    if (!hasCancelToken) {
+        logger_service_1.$logger.warn('[Networking] You can omit cancelToken — unsubscribing cancels the request automatically.', undefined, 'axios.observable');
+    }
+    let source$ = new rxjs_import_1.Observable((subscriber) => {
+        if (!hasCancelToken) {
+            cancelSource = networking_import_1.axios.CancelToken.source();
+            config.cancelToken = cancelSource.token;
+        }
+        promiseFactory(...args)
+            .then((response) => {
+            subscriber.next(response);
+            subscriber.complete();
+        })
+            .catch((error) => {
+            if (!subscriber.closed) {
+                subscriber.error(error);
+            }
+        });
+        return () => {
+            if (cancelSource) {
+                cancelSource.cancel('Request canceled via unsubscribe.');
+            }
+        };
+    });
+    // Add timeout if specified
+    if (options.timeoutMs) {
+        source$ = source$.pipe((0, rxjs_import_1.timeout)(options.timeoutMs));
+    }
+    // Add retry logic
+    if (options.retry) {
+        source$ = source$.pipe((0, rxjs_import_1.retry)(options.retry));
+    }
+    // Cache the response if needed
+    if (options.cache) {
+        source$ = source$.pipe((0, rxjs_import_1.shareReplay)({ bufferSize: 1, refCount: false }));
+    }
+    // Optional: Log or catch errors globally
+    source$ = source$.pipe((0, rxjs_import_1.catchError)((err) => {
+        logger_service_1.$logger.error('[createObservable error]:', err, 'axios.observable');
+        return (0, rxjs_import_1.throwError)(() => err);
+    }));
+    return source$;
+}

package/dist/src/core/base.provider.advanced.test.d.ts

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

package/dist/src/core/base.provider.advanced.test.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_provider_1 = require("./base.provider");
+describe('BaseProvider Advanced', () => {
+    const config = {
+        baseUrl: 'https://api.example.com',
+        isProd: false,
+        clientId: 'test-client',
+        apiKey: 'test-key',
+    };
+    it('should support dynamic getPath for multiple params', () => {
+        const provider = new base_provider_1.BaseProvider({
+            config,
+            path: '/resource/:id/:action',
+            method: 'GET',
+            headers: {},
+            getPath: (id, action) => `/resource/${id}/${action}`,
+        });
+        expect(provider.getPath('42', 'edit')).toBe('/resource/42/edit');
+    });
+    it('should allow dynamic headers and method', () => {
+        const provider = new base_provider_1.BaseProvider({
+            config,
+            path: '/resource',
+            method: 'PATCH',
+            headers: { Authorization: 'Bearer token' },
+        });
+        expect(provider.method).toBe('PATCH');
+        expect(provider.headers.Authorization).toBe('Bearer token');
+    });
+});

package/dist/src/core/base.provider.d.ts

@@ -0,0 +1,15 @@
+import { ProviderType, NetworkingConfig } from '../types/types';
+export declare class BaseProvider implements ProviderType {
+    baseURL: string;
+    path: string;
+    method: string;
+    headers: Record<string, string | undefined>;
+    getPath: (...queryParams: unknown[]) => string;
+    constructor({ config, path, method, headers, getPath, }: {
+        config: NetworkingConfig;
+        path: string;
+        method: string;
+        headers?: any;
+        getPath?: (...queryParams: any[]) => string;
+    });
+}

package/dist/src/core/base.provider.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProvider = void 0;
+class BaseProvider {
+    constructor({ config, path, method, headers = {}, getPath = () => path, }) {
+        this.baseURL = config.baseUrl;
+        this.path = path;
+        this.method = method;
+        this.headers = Object.assign(Object.assign({}, headers), { 'X-Client-Id': config.clientId, 'X-Api-Key': config.apiKey });
+        this.getPath = getPath || (() => path);
+    }
+}
+exports.BaseProvider = BaseProvider;

package/dist/src/core/base.provider.test.d.ts

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

package/dist/src/core/base.provider.test.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_provider_1 = require("./base.provider");
+describe('BaseProvider', () => {
+    const config = {
+        baseUrl: 'https://api.example.com',
+        isProd: false,
+        clientId: 'test-client',
+        apiKey: 'test-key',
+    };
+    it('should construct with required fields', () => {
+        const provider = new base_provider_1.BaseProvider({
+            config,
+            path: '/resource',
+            method: 'GET',
+            headers: { foo: 'bar' },
+        });
+        expect(provider.baseURL).toBe('https://api.example.com');
+        expect(provider.path).toBe('/resource');
+        expect(provider.method).toBe('GET');
+        expect(provider.headers).toEqual({ foo: 'bar', 'X-Client-Id': 'test-client', 'X-Api-Key': 'test-key' });
+        expect(provider.getPath()).toBe('/resource');
+    });
+    it('should use custom getPath if provided', () => {
+        const provider = new base_provider_1.BaseProvider({
+            config,
+            path: '/resource/:id',
+            method: 'GET',
+            headers: {},
+            getPath: (id) => `/resource/${id}`,
+        });
+        expect(provider.getPath('123')).toBe('/resource/123');
+    });
+});

package/dist/src/core/base.service.wrapper.advanced.test.d.ts

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

package/dist/src/core/base.service.wrapper.advanced.test.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_service_wrapper_1 = require("./base.service.wrapper");
+const types_1 = require("../types/types");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+describe('BaseServiceWrapper Advanced', () => {
+    const mockProvider = {
+        baseURL: 'https://api.example.com',
+        path: '/resource',
+        method: 'GET',
+        headers: {},
+        getPath: () => '/resource',
+    };
+    it('should allow use of RxJS operators', done => {
+        const wrapper = new base_service_wrapper_1.BaseServiceWrapper(mockProvider);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Required for test compatibility
+        wrapper.request = (() => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded({ foo: 1 })));
+        wrapper.request().pipe((0, operators_1.map)(r => r.response)).subscribe(val => {
+            expect(val).toEqual({ foo: 1 });
+            done();
+        });
+    });
+    it('should handle multiple concurrent requests', done => {
+        const wrapper = new base_service_wrapper_1.BaseServiceWrapper(mockProvider);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Required for test compatibility
+        wrapper.request = ((payload) => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded({ foo: payload })));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Required for test compatibility
+        const results = [];
+        wrapper.request(1).subscribe(r => {
+            results.push(r.response);
+            if (results.length === 1) {
+                expect(results[0]).toEqual({ foo: 1 });
+                done();
+            }
+        });
+    });
+});

package/dist/src/core/base.service.wrapper.d.ts

@@ -0,0 +1,7 @@
+import { ProviderType, NetworkingUIEventWrapped } from '../types/types';
+import { Observable } from 'rxjs';
+export declare class BaseServiceWrapper<T extends ProviderType> {
+    protected provider: T;
+    constructor(provider: T);
+    request<R = any>(payload?: any): Observable<NetworkingUIEventWrapped<R>>;
+}

package/dist/src/core/base.service.wrapper.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseServiceWrapper = void 0;
+const smess_service_1 = require("../domain/smess.service");
+class BaseServiceWrapper {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Required for base service wrapper compatibility
+    request(payload) {
+        const service = new smess_service_1.SmessService(this.provider);
+        return service.request(payload);
+    }
+}
+exports.BaseServiceWrapper = BaseServiceWrapper;

package/dist/src/core/base.service.wrapper.test.d.ts

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

package/dist/src/core/base.service.wrapper.test.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_service_wrapper_1 = require("./base.service.wrapper");
+const types_1 = require("../types/types");
+const rxjs_1 = require("rxjs");
+// Mock SmessService for testing
+jest.mock('../domain/smess.service', () => ({
+    SmessService: jest.fn().mockImplementation(() => ({
+        request: jest.fn(() => (0, rxjs_1.of)(types_1.NetworkingUIEventWrapped.succeeded({ foo: 'bar' })))
+    }))
+}));
+describe('BaseServiceWrapper', () => {
+    const mockProvider = {
+        baseURL: 'https://api.example.com',
+        path: '/resource',
+        method: 'GET',
+        headers: {},
+        getPath: () => '/resource',
+    };
+    it('should delegate request to SmessService', done => {
+        const wrapper = new base_service_wrapper_1.BaseServiceWrapper(mockProvider);
+        wrapper.request().subscribe(result => {
+            expect(result.response).toEqual({ foo: 'bar' });
+            done();
+        });
+    });
+});

package/dist/src/core/rx.http.service.d.ts

@@ -0,0 +1,51 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from '../utils/networking-import';
+import type { AxiosInterceptorManager } from 'axios';
+import { AxiosObservable } from './axios.observable';
+export interface Axiosable {
+    request<T = unknown>(config: AxiosRequestConfig): AxiosObservable<T>;
+    get<T = unknown>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    head<T = unknown>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    post<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): AxiosObservable<T>;
+    put<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): AxiosObservable<T>;
+    patch<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): AxiosObservable<T>;
+    delete<T = unknown>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+}
+declare class HttpService implements Axiosable {
+    private axiosInstance;
+    static defaults: Omit<import("axios").AxiosDefaults<any>, "headers"> & {
+        headers: import("axios").HeadersDefaults & {
+            [key: string]: import("axios").AxiosHeaderValue;
+        };
+    };
+    static interceptors: {
+        request: AxiosInterceptorManager<import("axios").InternalAxiosRequestConfig>;
+        response: AxiosInterceptorManager<AxiosResponse>;
+    };
+    constructor(axiosInstance: AxiosInstance);
+    get defaults(): Omit<import("axios").AxiosDefaults<any>, "headers"> & {
+        headers: import("axios").HeadersDefaults & {
+            [key: string]: import("axios").AxiosHeaderValue;
+        };
+    };
+    get interceptors(): {
+        request: AxiosInterceptorManager<import("axios").InternalAxiosRequestConfig>;
+        response: AxiosInterceptorManager<AxiosResponse>;
+    };
+    static request<T = unknown>(config: AxiosRequestConfig): AxiosObservable<T>;
+    static get<T = unknown>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static post<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static put<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static patch<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static delete<T = unknown>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static head<T = unknown>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    static create(config: AxiosRequestConfig): HttpService;
+    request<T = unknown>(config: AxiosRequestConfig): AxiosObservable<T>;
+    get<T = unknown>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    post<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): AxiosObservable<T>;
+    put<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): AxiosObservable<T>;
+    patch<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): AxiosObservable<T>;
+    delete<T = unknown>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+    head<T = unknown>(url: string, config?: AxiosRequestConfig): AxiosObservable<T>;
+}
+export default HttpService;
+export { HttpService };

package/dist/src/core/rx.http.service.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpService = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any -- Required for axios compatibility */
+const networking_import_1 = require("../utils/networking-import");
+const axios_observable_1 = require("./axios.observable");
+class HttpService {
+    constructor(axiosInstance) {
+        this.axiosInstance = axiosInstance;
+    }
+    get defaults() {
+        return this.axiosInstance.defaults;
+    }
+    get interceptors() {
+        return this.axiosInstance.interceptors;
+    }
+    // Static methods
+    static request(config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.request, [config]);
+    }
+    static get(url, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.get, [url, config]);
+    }
+    static post(url, data, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.post, [url, data, config]);
+    }
+    static put(url, data, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.put, [url, data, config]);
+    }
+    static patch(url, data, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.patch, [url, data, config]);
+    }
+    static delete(url, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.delete, [url, config]);
+    }
+    static head(url, config) {
+        return (0, axios_observable_1.createObservable)(networking_import_1.axios.head, [url, config]);
+    }
+    static create(config) {
+        return new HttpService(networking_import_1.axios.create(config));
+    }
+    // Instance methods
+    request(config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.request, [config]);
+    }
+    get(url, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.get, [url, config]);
+    }
+    post(url, data, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.post, [url, data, config]);
+    }
+    put(url, data, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.put, [url, data, config]);
+    }
+    patch(url, data, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.patch, [url, data, config]);
+    }
+    delete(url, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.delete, [url, config]);
+    }
+    head(url, config) {
+        return (0, axios_observable_1.createObservable)(this.axiosInstance.head, [url, config]);
+    }
+}
+exports.HttpService = HttpService;
+HttpService.defaults = networking_import_1.axios.defaults;
+HttpService.interceptors = networking_import_1.axios.interceptors;
+exports.default = HttpService;

package/dist/src/domain/auth.provider.d.ts

@@ -0,0 +1,12 @@
+import { ProviderType, NetworkingConfig } from '../types/types';
+export type AuthTarget = 'get-profile' | 'login' | 'logout' | 'register' | 'update-profile' | 'change-password' | 'password-forgot' | 'reset-password';
+export declare class AuthProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    constructor(config: NetworkingConfig, target: AuthTarget);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string | undefined>;
+    getPath(...queryParams: unknown[]): string;
+}