@smess/networking 1.0.29 → 1.0.30

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

@@ -0,0 +1,29 @@
+import { BaseProvider } from "./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 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 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 @@
+export class BaseProvider {
+    constructor({ config, path, method, headers = {}, getPath = () => path, }) {
+        this.baseURL = config.baseUrl;
+        this.path = path;
+        this.method = method;
+        this.headers = {
+            ...headers,
+            "X-Client-Id": config.clientId,
+            "X-Api-Key": config.apiKey,
+        };
+        this.getPath = getPath || (() => path);
+    }
+}

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

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

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

@@ -0,0 +1,36 @@
+import { BaseProvider } from "./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 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 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,39 @@
+import { BaseServiceWrapper } from "./base.service.wrapper";
+import { NetworkingUIEventWrapped } from "../types/types";
+import { of } from "rxjs";
+import { map } from "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 BaseServiceWrapper(mockProvider);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Required for test compatibility
+        wrapper.request = (() => of(NetworkingUIEventWrapped.succeeded({ foo: 1 })));
+        wrapper
+            .request()
+            .pipe(map((r) => r.response))
+            .subscribe((val) => {
+            expect(val).toEqual({ foo: 1 });
+            done();
+        });
+    });
+    it("should handle multiple concurrent requests", (done) => {
+        const wrapper = new BaseServiceWrapper(mockProvider);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Required for test compatibility
+        wrapper.request = ((payload) => of(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,11 @@
+import { SmessService } from "../services/smess.service";
+export 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 SmessService(this.provider);
+        return service.request(payload);
+    }
+}

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,25 @@
+import { BaseServiceWrapper } from "./base.service.wrapper";
+import { NetworkingUIEventWrapped } from "../types/types";
+import { of } from "rxjs";
+// Mock SmessService for testing
+jest.mock("../services/smess.service", () => ({
+    SmessService: jest.fn().mockImplementation(() => ({
+        request: jest.fn(() => of(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 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,65 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- Required for axios compatibility */
+import { axios, } from "../utils/networking-import";
+import { createObservable } from "./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 createObservable(axios.request, [config]);
+    }
+    static get(url, config) {
+        return createObservable(axios.get, [url, config]);
+    }
+    static post(url, data, config) {
+        return createObservable(axios.post, [url, data, config]);
+    }
+    static put(url, data, config) {
+        return createObservable(axios.put, [url, data, config]);
+    }
+    static patch(url, data, config) {
+        return createObservable(axios.patch, [url, data, config]);
+    }
+    static delete(url, config) {
+        return createObservable(axios.delete, [url, config]);
+    }
+    static head(url, config) {
+        return createObservable(axios.head, [url, config]);
+    }
+    static create(config) {
+        return new HttpService(axios.create(config));
+    }
+    // Instance methods
+    request(config) {
+        return createObservable(this.axiosInstance.request, [config]);
+    }
+    get(url, config) {
+        return createObservable(this.axiosInstance.get, [url, config]);
+    }
+    post(url, data, config) {
+        return createObservable(this.axiosInstance.post, [url, data, config]);
+    }
+    put(url, data, config) {
+        return createObservable(this.axiosInstance.put, [url, data, config]);
+    }
+    patch(url, data, config) {
+        return createObservable(this.axiosInstance.patch, [url, data, config]);
+    }
+    delete(url, config) {
+        return createObservable(this.axiosInstance.delete, [url, config]);
+    }
+    head(url, config) {
+        return createObservable(this.axiosInstance.head, [url, config]);
+    }
+}
+HttpService.defaults = axios.defaults;
+HttpService.interceptors = axios.interceptors;
+export default HttpService;
+export { HttpService };

package/dist/src/index.d.ts

@@ -0,0 +1,25 @@
+export * from "./services/user.service";
+export * from "./services/product.service";
+export * from "./services/auth.service";
+export * from "./services/store.service";
+export * from "./services/store.cart.service";
+export * from "./services/store.product.service";
+export * from "./services/customer.service";
+export * from "./services/employee.service";
+export * from "./services/order.service";
+export * from "./services/cache.service";
+export * from "./services/smess.service";
+export * from "./services/utils/withAuthReset";
+export * from "./services/storefront.product.service";
+export * from "./services/storefront.store.service";
+export * from "./services/storefront.cart.service";
+export * from "./services/storefront.checkout.service";
+export * from "./services/storefront.order.service";
+export * from "./services/storefront.customer.metadata.service";
+export * from "./core/base.provider";
+export * from "./core/base.service.wrapper";
+export * from "./core/axios.observable";
+export * from "./types/types";
+export { $logger } from "./services/logger.service";
+export declare const baseURL: () => string;
+export declare const apiVersion: () => string;

package/dist/src/index.js

@@ -0,0 +1,29 @@
+export * from "./services/user.service";
+export * from "./services/product.service";
+export * from "./services/auth.service";
+export * from "./services/store.service";
+export * from "./services/store.cart.service";
+export * from "./services/store.product.service";
+export * from "./services/customer.service";
+export * from "./services/employee.service";
+export * from "./services/order.service";
+export * from "./services/cache.service";
+export * from "./services/smess.service";
+export * from "./services/utils/withAuthReset";
+export * from "./services/storefront.product.service";
+export * from "./services/storefront.store.service";
+export * from "./services/storefront.cart.service";
+export * from "./services/storefront.checkout.service";
+export * from "./services/storefront.order.service";
+export * from "./services/storefront.customer.metadata.service";
+export * from "./core/base.provider";
+export * from "./core/base.service.wrapper";
+export * from "./core/axios.observable";
+export * from "./types/types";
+export { $logger } from "./services/logger.service";
+export const baseURL = () => {
+    return "";
+};
+export const apiVersion = () => {
+    return "api/v1";
+};

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

@@ -0,0 +1,65 @@
+import { ProviderType, NetworkingConfig, NetworkingUIEventWrapped, HttpResponse } from "../types/types";
+import { SmessService } from "./smess.service";
+import { BehaviorSubject, Observable } from "rxjs";
+export interface AuthLoginRequest {
+    identifier: string;
+    password: string;
+    rememberMe?: boolean;
+}
+export interface ForgotPasswordRequest {
+    identifier: string;
+}
+export interface AuthChangePasswordRequest {
+    old_password: string;
+    password: string;
+}
+export interface ResetPasswordRequest {
+    token: string;
+    password: string;
+}
+export type AuthLoginResponse = {
+    token_type: unknown;
+    expires_in: unknown;
+    token: unknown;
+    refresh_token: unknown;
+};
+export type AuthTarget = "login" | "logout" | "change-password" | "password-forgot" | "reset-password" | "verify-reset-password-token";
+export declare class AuthProvider implements ProviderType {
+    private readonly config;
+    private readonly target;
+    private readonly $authToken;
+    constructor(config: NetworkingConfig, target: AuthTarget, $authToken: BehaviorSubject<string | null>);
+    get baseURL(): string;
+    get path(): string;
+    get method(): string;
+    get headers(): Record<string, string>;
+    getPath(...queryParams: unknown[]): string;
+}
+export interface AuthServiceType {
+    provider(target: AuthTarget): SmessService<AuthProvider>;
+    login(payload: AuthLoginRequest): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
+    logout(): Observable<NetworkingUIEventWrapped<void>>;
+    forgotPassword(payload: ForgotPasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    changePassword(payload: AuthChangePasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    resetPassword(payload: ResetPasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    verifyResetPasswordToken(token: string): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
+}
+export declare class AuthService implements AuthServiceType {
+    private readonly config;
+    private readonly $_authToken;
+    constructor(config: NetworkingConfig);
+    get $authToken(): BehaviorSubject<string | null>;
+    get currentAuthToken(): string | null;
+    private getValidToken;
+    private loadFromStorage;
+    private loadAuthFromStorage;
+    private saveAuthToStorage;
+    private clearAuthFromStorage;
+    provider(target: AuthTarget): SmessService<AuthProvider>;
+    login(payload: AuthLoginRequest): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
+    logout(): Observable<NetworkingUIEventWrapped<void>>;
+    forgotPassword(payload: ForgotPasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    changePassword(payload: AuthChangePasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    resetPassword(payload: ResetPasswordRequest): Observable<NetworkingUIEventWrapped<HttpResponse>>;
+    verifyResetPasswordToken(token: string): Observable<NetworkingUIEventWrapped<AuthLoginResponse>>;
+}

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

@@ -0,0 +1,197 @@
+import { Accept, SMESSHeader, SmessService } from "./smess.service";
+import { BehaviorSubject } from "rxjs";
+import { tap } from "rxjs/operators";
+// LocalStorage keys for auth persistence
+const AUTH_TOKEN_KEY = 'smess_auth_token';
+const AUTH_RESPONSE_KEY = 'smess_auth_response';
+export class AuthProvider {
+    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 "login":
+                return "/authentication/login_check";
+            case "password-forgot":
+                return "/authentication/forgot-password";
+            case "reset-password":
+                return "/authentication/reset-password";
+            case "verify-reset-password-token":
+                return "/authentication/verify-reset-password-token";
+            case "logout":
+                return "/authentication/logout";
+            case "change-password":
+                return "/authentication/change-password";
+            default:
+                return "/authentication";
+        }
+    }
+    get method() {
+        switch (this.target) {
+            default:
+                return "POST";
+        }
+    }
+    get headers() {
+        let authHeaders = {};
+        switch (this.target) {
+            case "login":
+            case "password-forgot":
+            case "reset-password":
+            case "verify-reset-password-token":
+                authHeaders = SmessService.getHeaders(Accept.V1);
+                break;
+            default:
+                authHeaders = SmessService.getHeaders(Accept.V1, this.$authToken.value);
+        }
+        if (this.config.clientId) {
+            authHeaders[SMESSHeader.ClientId] = this.config.clientId;
+        }
+        if (this.config.apiKey) {
+            authHeaders[SMESSHeader.ApiKey] = this.config.apiKey;
+        }
+        return SmessService.filterHeaders(authHeaders);
+    }
+    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 AuthService {
+    constructor(config) {
+        this.config = config;
+        this.$_authToken = new BehaviorSubject(null);
+        this.loadAuthFromStorage();
+    }
+    // Getter that returns BehaviorSubject with token validation
+    get $authToken() {
+        const currentToken = this.getValidToken();
+        if (currentToken !== this.$_authToken.value) {
+            this.$_authToken.next(currentToken);
+        }
+        return this.$_authToken;
+    }
+    // Get current auth token value
+    get currentAuthToken() {
+        return this.getValidToken();
+    }
+    // Get valid token from memory or localStorage
+    getValidToken() {
+        // If we have a token in memory, return it (assume it's valid)
+        if (this.$_authToken.value) {
+            return this.$_authToken.value;
+        }
+        // Otherwise, try to load from localStorage
+        return this.loadFromStorage();
+    }
+    // Load token from localStorage and check expiration
+    loadFromStorage() {
+        try {
+            const storedResponse = localStorage.getItem(AUTH_RESPONSE_KEY);
+            const storedAt = localStorage.getItem(`${AUTH_RESPONSE_KEY}_stored_at`);
+            if (storedResponse && storedAt) {
+                const authResponse = JSON.parse(storedResponse);
+                const storedTime = parseInt(storedAt, 10);
+                // Check if token is expired
+                if (authResponse.expires_in && typeof authResponse.expires_in === 'number') {
+                    const expirationTime = storedTime + (authResponse.expires_in * 1000);
+                    if (Date.now() >= expirationTime) {
+                        // Token expired, clear storage
+                        this.clearAuthFromStorage();
+                        return null;
+                    }
+                }
+                // Token is valid, store in memory and return
+                const token = String(authResponse.token);
+                this.$_authToken.next(token);
+                return token;
+            }
+        }
+        catch (error) {
+            console.warn('Failed to load token from localStorage:', error);
+            this.clearAuthFromStorage();
+        }
+        return null;
+    }
+    // Load auth token from localStorage on initialization
+    loadAuthFromStorage() {
+        this.loadFromStorage();
+    }
+    // Save auth response to localStorage
+    saveAuthToStorage(authResponse) {
+        try {
+            localStorage.setItem(AUTH_TOKEN_KEY, String(authResponse.token));
+            localStorage.setItem(AUTH_RESPONSE_KEY, JSON.stringify(authResponse));
+            localStorage.setItem(`${AUTH_RESPONSE_KEY}_stored_at`, Date.now().toString());
+            // Update memory
+            this.$_authToken.next(String(authResponse.token));
+        }
+        catch (error) {
+            console.warn('Failed to save auth to localStorage:', error);
+        }
+    }
+    // Clear auth from localStorage
+    clearAuthFromStorage() {
+        try {
+            localStorage.removeItem(AUTH_TOKEN_KEY);
+            localStorage.removeItem(AUTH_RESPONSE_KEY);
+            localStorage.removeItem(`${AUTH_RESPONSE_KEY}_stored_at`);
+            // Clear memory
+            this.$_authToken.next(null);
+        }
+        catch (error) {
+            console.warn('Failed to clear auth from localStorage:', error);
+        }
+    }
+    provider(target) {
+        const targetWrapper = new AuthProvider(this.config, target, this.$authToken);
+        return new SmessService(targetWrapper);
+    }
+    login(payload) {
+        return this.provider("login")
+            .request(payload)
+            .pipe(tap((result) => {
+            if (result.hasSuccess && result.response?.token) {
+                // Set the auth token when login is successful
+                this.$_authToken.next(String(result.response.token));
+                // Save to localStorage if rememberMe is true
+                if (payload.rememberMe && result.response) {
+                    this.saveAuthToStorage(result.response);
+                }
+            }
+        }));
+    }
+    logout() {
+        return this.provider("logout")
+            .request()
+            .pipe(tap((result) => {
+            if (result.hasSuccess) {
+                // Clear from localStorage (this will also clear memory)
+                this.clearAuthFromStorage();
+            }
+        }));
+    }
+    forgotPassword(payload) {
+        return this.provider("password-forgot").request(payload);
+    }
+    changePassword(payload) {
+        return this.provider("change-password").request(payload);
+    }
+    resetPassword(payload) {
+        return this.provider("reset-password").request(payload);
+    }
+    verifyResetPasswordToken(token) {
+        return this.provider("verify-reset-password-token").request({ token });
+    }
+}

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

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