@nu-art/thunderstorm-frontend 0.400.5

package/modules/ModuleFE_BaseTheme.js

@@ -0,0 +1,27 @@
+import { _keys, Module } from '@nu-art/ts-common';
+import { StorageKey } from './ModuleFE_LocalStorage.js';
+export class ModuleFE_BaseTheme extends Module {
+    options;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    init() {
+        _keys(this.options).forEach((option) => {
+            return this.setThemeProp(option, this.getThemeProp(option));
+        });
+    }
+    getOptions = () => this.options;
+    setThemeProp(themeKey, themeValue) {
+        const _themeKey = themeKey;
+        document.querySelector('body')?.setAttribute(_themeKey, themeValue);
+        this.createStorageKey(themeKey).set(themeValue);
+    }
+    getThemeProp(themeKey) {
+        return this.createStorageKey(themeKey).get(this.options[themeKey][0]);
+    }
+    createStorageKey(themeKey) {
+        const _themeKey = themeKey;
+        return new StorageKey(`theme-key--${_themeKey}`);
+    }
+}

package/modules/ModuleFE_BroadcastChannel/ModuleFE_BroadcastChannel.d.ts

@@ -0,0 +1,20 @@
+import { Logger, Module } from '@nu-art/ts-common';
+import { Message } from '../ModuleFE_WindowMessenger.js';
+declare class ModuleFE_BroadcastChannel_Class extends Module {
+    private channels;
+    private register;
+    private unregister;
+    private sendMessage;
+}
+export declare const ModuleFE_BroadcastChannel: ModuleFE_BroadcastChannel_Class;
+export declare class TS_BroadcastChannel<T extends Message> extends Logger {
+    readonly channelTopic: string;
+    private readonly messageProcessorMap;
+    constructor(channelTopic: string);
+    sendMessage: (message: T) => void;
+    mount: () => this;
+    unmount: () => void;
+    addProcessor: <K extends T>(key: K["key"], processor: (message: K) => void) => this;
+    execute: (message: T) => void;
+}
+export {};

package/modules/ModuleFE_BroadcastChannel/ModuleFE_BroadcastChannel.js

@@ -0,0 +1,66 @@
+import { __stringify, Logger, Module } from '@nu-art/ts-common';
+class ModuleFE_BroadcastChannel_Class extends Module {
+    //######################### Static #########################
+    channels = {};
+    //######################### Life Cycle #########################
+    register = (receiver) => {
+        if (this.channels[receiver.channelTopic])
+            return this.logWarning(`already registered channel: ${receiver.channelTopic}`);
+        this.logInfo(`registered channel: ${receiver.channelTopic}`);
+        const channel = new BroadcastChannel(receiver.channelTopic);
+        this.channels[receiver.channelTopic] = channel;
+        channel.onmessage = (message) => {
+            this.logDebug('message', message);
+            receiver.execute(message.data);
+        };
+    };
+    unregister = (receiver) => {
+        if (!this.channels[receiver.channelTopic])
+            return;
+        const channel = this.channels[receiver.channelTopic];
+        delete this.channels[receiver.channelTopic];
+        channel.close();
+    };
+    sendMessage = (channel, message) => {
+        this.logDebug(`sending message: ${__stringify(message)}`);
+        this.channels[channel.channelTopic].postMessage(message);
+    };
+}
+export const ModuleFE_BroadcastChannel = new ModuleFE_BroadcastChannel_Class();
+export class TS_BroadcastChannel extends Logger {
+    channelTopic;
+    messageProcessorMap = {};
+    constructor(channelTopic) {
+        super(`BroadcastChannel-${channelTopic}`);
+        this.channelTopic = channelTopic;
+    }
+    sendMessage = (message) => {
+        // @ts-ignore
+        const sendMessage = ModuleFE_BroadcastChannel.sendMessage;
+        sendMessage(this, message);
+    };
+    mount = () => {
+        // @ts-ignore
+        const register = ModuleFE_BroadcastChannel.register;
+        register(this);
+        return this;
+    };
+    unmount = () => {
+        // @ts-ignore
+        const unregister = ModuleFE_BroadcastChannel.unregister;
+        unregister(this);
+    };
+    addProcessor = (key, processor) => {
+        this.messageProcessorMap[key] = processor;
+        return this;
+    };
+    execute = (message) => {
+        const processor = this.messageProcessorMap[message.key];
+        if (!processor) {
+            this.logError('No message processor defined for key ${message.key}');
+            return;
+        }
+        this.logDebug(`received message: ${__stringify(message)}`);
+        processor(message);
+    };
+}

package/modules/ModuleFE_BrowserHistory.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Created by tacb0ss on 27/07/2018.
+ */
+import { Module } from '@nu-art/ts-common';
+import { History, LocationDescriptorObject } from 'history';
+import { UrlQueryParams } from '@nu-art/thunderstorm-shared';
+import { ThunderDispatcher } from '../core/thunder-dispatcher.js';
+export type OnUrlParamsChangedListener = {
+    __onUrlParamsChanged: VoidFunction;
+};
+export declare const dispatcher_urlParamsChanged: ThunderDispatcher<OnUrlParamsChangedListener, "__onUrlParamsChanged", [], void>;
+export declare class ModuleFE_BrowserHistory_Class extends Module {
+    private readonly history;
+    constructor();
+    /**
+     * Update and navigate according to query params
+     */
+    push(push: LocationDescriptorObject): void;
+    /**
+     * Update query params
+     */
+    replace(push: LocationDescriptorObject): void;
+    private composeQuery;
+    private getEncodedQueryParams;
+    getQueryParams(): UrlQueryParams;
+    setQuery(queryParams: UrlQueryParams): void;
+    addQueryParam(key: string, value: string): void;
+    removeQueryParam(key: string): void;
+    setUrl(url: string, queryParams?: UrlQueryParams): void;
+    private createHistoryDataFromQueryParams;
+    private updateQueryParams;
+    getOrigin(): string;
+    getCurrent(): import("history").Location<any>;
+    getHistory(): History<any>;
+    getQueryParameter(key: string): string | null | undefined;
+    getCurrentUrl(): string;
+}
+export declare function getCurrentUrl(): string;
+export declare function getQueryParameter(name: string): string | null | undefined;
+export declare function getUrlQuery(): UrlQueryParams;
+export declare function encodeUrlParams(queryParams?: UrlQueryParams): {
+    [key: string]: string | undefined;
+};
+export declare function composeQuery(queryParams?: UrlQueryParams): string;
+export declare function composeURL(url: string, queryParams?: UrlQueryParams): string;
+export declare const ModuleFE_BrowserHistory: ModuleFE_BrowserHistory_Class;

package/modules/ModuleFE_BrowserHistory.js

@@ -0,0 +1,165 @@
+/*
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Created by tacb0ss on 27/07/2018.
+ */
+import { _keys, composeQueryParams, exists, Module, } from '@nu-art/ts-common';
+import { createBrowserHistory } from 'history';
+import { ThunderDispatcher } from '../core/thunder-dispatcher.js';
+export const dispatcher_urlParamsChanged = new ThunderDispatcher('__onUrlParamsChanged');
+// move all the shit from here to the Routing module
+export class ModuleFE_BrowserHistory_Class extends Module {
+    history;
+    constructor() {
+        super();
+        this.history = createBrowserHistory();
+    }
+    /**
+     * Update and navigate according to query params
+     */
+    push(push) {
+        this.history.push(push);
+    }
+    /**
+     * Update query params
+     */
+    replace(push) {
+        this.history.replace(push);
+    }
+    composeQuery(queryParams) {
+        const queryAsString = composeQueryParams(queryParams);
+        if (queryAsString.length === 0)
+            return undefined;
+        return queryAsString;
+    }
+    getEncodedQueryParams = () => {
+        const queryParams = {};
+        let queryAsString = window.location.search;
+        if (!queryAsString || queryAsString.length === 0)
+            return {};
+        while (queryAsString.startsWith('?') || queryAsString.startsWith('/?')) {
+            if (queryAsString.startsWith('?'))
+                queryAsString = queryAsString.substring(1);
+            else if (queryAsString.startsWith('/?'))
+                queryAsString = queryAsString.substring(2);
+            else
+                break;
+        }
+        const query = queryAsString.split('&');
+        return query.map(param => {
+            const parts = param.split('=');
+            return { key: parts[0], value: parts[1].length === 0 ? undefined : parts[1] };
+        }).reduce((toRet, param) => {
+            toRet[param.key] = param.value;
+            return toRet;
+        }, queryParams);
+    };
+    getQueryParams() {
+        const params = this.getEncodedQueryParams();
+        _keys(params).forEach(key => {
+            const _param = params[key];
+            if (!exists(_param))
+                return;
+            const value = `${params[key]}`;
+            params[key] = decodeURIComponent(value);
+        });
+        return params;
+    }
+    setQuery(queryParams) {
+        const encodedQueryParams = encodeUrlParams(queryParams);
+        this.updateQueryParams(encodedQueryParams);
+    }
+    addQueryParam(key, value) {
+        const decodedQueryParams = this.getQueryParams();
+        decodedQueryParams[key] = value;
+        this.updateQueryParams(decodedQueryParams);
+    }
+    removeQueryParam(key) {
+        const encodedQueryParams = this.getEncodedQueryParams();
+        delete encodedQueryParams[key];
+        const data = this.createHistoryDataFromQueryParams(encodedQueryParams);
+        this.replace(data);
+    }
+    setUrl(url, queryParams) {
+        this.push(this.createHistoryDataFromQueryParams(queryParams, url));
+    }
+    createHistoryDataFromQueryParams(encodedQueryParams, pathname = window.location.pathname) {
+        return {
+            pathname: !pathname.endsWith('/') ? pathname : pathname.substring(0, pathname.length - 1),
+            search: !encodedQueryParams ? '' : this.composeQuery(encodedQueryParams)
+        };
+    }
+    updateQueryParams(encodedQueryParams) {
+        const data = this.createHistoryDataFromQueryParams(encodedQueryParams);
+        this.replace(data);
+    }
+    getOrigin() {
+        return window.location.origin;
+    }
+    getCurrent() {
+        return this.history.location;
+    }
+    getHistory() {
+        return this.history;
+    }
+    getQueryParameter(key) {
+        const queryParams = ModuleFE_BrowserHistory.getQueryParams();
+        const value = queryParams[key];
+        if (value === undefined && Object.keys(queryParams).includes(key))
+            return null;
+        return value;
+    }
+    getCurrentUrl() {
+        return ModuleFE_BrowserHistory.getCurrent().pathname;
+    }
+}
+export function getCurrentUrl() {
+    return ModuleFE_BrowserHistory.getCurrentUrl();
+}
+export function getQueryParameter(name) {
+    return ModuleFE_BrowserHistory.getQueryParameter(name);
+}
+export function getUrlQuery() {
+    return ModuleFE_BrowserHistory.getQueryParams();
+}
+export function encodeUrlParams(queryParams) {
+    const encodedQueryParams = { ...queryParams };
+    _keys(encodedQueryParams).forEach(key => {
+        const value = encodedQueryParams[key];
+        if (!value) {
+            delete encodedQueryParams[key];
+            return;
+        }
+        encodedQueryParams[key] = encodeURIComponent(value);
+    });
+    return encodedQueryParams;
+}
+export function composeQuery(queryParams) {
+    const queryAsString = composeQueryParams(queryParams);
+    if (queryAsString.length === 0)
+        return '';
+    return queryAsString;
+}
+export function composeURL(url, queryParams) {
+    const queryAsString = composeQuery(queryParams);
+    return `${url}${queryAsString.length > 0 ? `?${queryAsString}` : ''}`;
+}
+export const ModuleFE_BrowserHistory = new ModuleFE_BrowserHistory_Class();

package/modules/ModuleFE_BrowserHistoryV2.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Created by tacb0ss on 27/07/2018.
+ */
+import { Module, Primitive, RecursiveArrayOfPrimitives, RecursiveObjectOfPrimitives } from '@nu-art/ts-common';
+import { LocationDescriptorObject } from 'history';
+import { ThunderDispatcher } from '../core/thunder-dispatcher.js';
+type AdvancedQueryParam = Primitive | RecursiveObjectOfPrimitives | RecursiveArrayOfPrimitives;
+export declare class QueryParamKey<T extends AdvancedQueryParam> {
+    private readonly key;
+    constructor(key: string);
+    get(): T;
+    set(value: T): void;
+    update(value: T): void;
+    delete(): void;
+}
+export type OnUrlParamsChangedListenerV2 = {
+    __onUrlParamsChangedV2: VoidFunction;
+};
+export declare const dispatcher_urlParamsChangedV2: ThunderDispatcher<OnUrlParamsChangedListenerV2, "__onUrlParamsChangedV2", [], void>;
+export declare class ModuleFE_BrowserHistoryV2_Class extends Module {
+    private readonly history;
+    private state;
+    constructor();
+    private decode;
+    private encode;
+    /**
+     * Update and navigate according to query params
+     */
+    push(push: LocationDescriptorObject): void;
+    /**
+     * Update query params
+     */
+    replace(push: LocationDescriptorObject): void;
+    update(queryParams: AdvancedQueryParam): void;
+    set(key: string, queryParams: AdvancedQueryParam): void;
+    setObject(object: RecursiveObjectOfPrimitives): void;
+    get(key: string): Readonly<AdvancedQueryParam | undefined>;
+    delete(key: string): void;
+    setState: (state: RecursiveObjectOfPrimitives) => void;
+    getState: () => Readonly<RecursiveObjectOfPrimitives>;
+}
+export declare const ModuleFE_BrowserHistoryV2: ModuleFE_BrowserHistoryV2_Class;
+export {};

package/modules/ModuleFE_BrowserHistoryV2.js

@@ -0,0 +1,113 @@
+/*
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Created by tacb0ss on 27/07/2018.
+ */
+import { _keys, compare, merge, Module } from '@nu-art/ts-common';
+import { createBrowserHistory } from 'history';
+import { gzip, ungzip } from 'pako';
+import { ThunderDispatcher } from '../core/thunder-dispatcher.js';
+export class QueryParamKey {
+    key;
+    constructor(key) {
+        this.key = key;
+    }
+    // @ts-ignore
+    get() {
+        return ModuleFE_BrowserHistoryV2.get(this.key);
+    }
+    set(value) {
+        return ModuleFE_BrowserHistoryV2.set(this.key, value);
+    }
+    update(value) {
+        return ModuleFE_BrowserHistoryV2.update({ [this.key]: value });
+    }
+    delete() {
+        return ModuleFE_BrowserHistoryV2.delete(this.key);
+    }
+}
+export const dispatcher_urlParamsChangedV2 = new ThunderDispatcher('__onUrlParamsChangedV2');
+export class ModuleFE_BrowserHistoryV2_Class extends Module {
+    history;
+    state;
+    constructor() {
+        super();
+        this.history = createBrowserHistory();
+        this.state = this.decode();
+    }
+    decode(hash = window.location.hash) {
+        if (!hash || hash.length === 0)
+            return {};
+        if (hash.startsWith('#'))
+            hash = hash.substring(1);
+        return JSON.parse(new TextDecoder('utf8').decode(ungzip(Uint8Array.from(window.atob(hash || window.location.hash), c => c.charCodeAt(0)))));
+    }
+    encode(state = this.state) {
+        this.state = Object.freeze(state);
+        window.location.hash = window.btoa(new Uint8Array(gzip(JSON.stringify(this.state))).reduce((acc, byte) => acc + String.fromCharCode(byte), ''));
+        dispatcher_urlParamsChangedV2.dispatchUI();
+    }
+    /**
+     * Update and navigate according to query params
+     */
+    push(push) {
+        this.history.push(push);
+    }
+    /**
+     * Update query params
+     */
+    replace(push) {
+        this.history.replace(push);
+        const lastState = this.state;
+        this.state = this.decode();
+        if (!compare(this.state, lastState))
+            dispatcher_urlParamsChangedV2.dispatchUI();
+    }
+    update(queryParams) {
+        this.state = merge(this.state, queryParams);
+        this.encode();
+    }
+    set(key, queryParams) {
+        const state = { ...this.state };
+        state[key] = queryParams;
+        this.encode(state);
+    }
+    setObject(object) {
+        const state = { ...this.state };
+        _keys(object).forEach(key => {
+            state[key] = object[key];
+        });
+        this.encode(state);
+    }
+    get(key) {
+        return this.state[key];
+    }
+    delete(key) {
+        const state = { ...this.state };
+        delete state[key];
+        this.encode(state);
+    }
+    setState = (state) => {
+        this.encode(state);
+    };
+    getState = () => this.state;
+}
+export const ModuleFE_BrowserHistoryV2 = new ModuleFE_BrowserHistoryV2_Class();

package/modules/ModuleFE_CSVParser.d.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nu-art/ts-common';
+import * as Papa from 'papaparse';
+import { LocalFile, UnparseConfig } from 'papaparse';
+export type PapaparseConfig = Omit<Papa.ParseRemoteConfig, 'download'>;
+declare class ModuleFE_CSVParser_Class extends Module {
+    fromString: <T>(str: string, _config?: Papa.ParseConfig<T>) => T[];
+    fromFile: <T>(file: LocalFile, _config: Papa.ParseLocalConfig<T, LocalFile>) => Promise<T[]>;
+    fromURL: <T>(url: string, _config: Omit<Papa.ParseRemoteConfig<T>, "download">) => Promise<T[]>;
+    toString: <T>(items: T[], config?: UnparseConfig) => string;
+}
+export declare const ModuleFE_CSVParser: ModuleFE_CSVParser_Class;
+export {};

package/modules/ModuleFE_CSVParser.js

@@ -0,0 +1,52 @@
+import { Module } from '@nu-art/ts-common';
+import * as Papa from 'papaparse';
+class ModuleFE_CSVParser_Class extends Module {
+    fromString = (str, _config) => {
+        const config = { header: true, ..._config ?? {} };
+        const parsed = Papa.parse(str, config);
+        if (parsed.errors.length)
+            this.logError('Parsed with errors', ...parsed.errors);
+        this.logDebug('Parsed metadata', parsed.meta);
+        return parsed.data;
+    };
+    fromFile = async (file, _config) => {
+        return new Promise(resolve => {
+            const config = {
+                header: true,
+                complete: (results, file) => {
+                    if (results.errors.length)
+                        this.logError('Parsed with errors', ...results.errors);
+                    this.logDebug('Parsed metadata', results.meta);
+                    resolve(results.data);
+                },
+                ..._config,
+            };
+            Papa.parse(file, config);
+        });
+    };
+    fromURL = async (url, _config) => {
+        return new Promise((resolve, reject) => {
+            // const error = tsValidate(url, tsValidateGeneralUrl());
+            // if (error)
+            // 	reject(error);
+            const config = {
+                header: true,
+                complete: (results, file) => {
+                    if (results.errors.length)
+                        this.logError('Parsed with errors', ...results.errors);
+                    this.logDebug('Parsed metadata', results.meta);
+                    resolve(results.data);
+                },
+                ..._config,
+                download: true,
+            };
+            Papa.parse(url, config);
+        });
+    };
+    toString = (items, config) => {
+        if (!items?.length)
+            return '';
+        return Papa.unparse(items, { header: true, ...(config ?? {}) });
+    };
+}
+export const ModuleFE_CSVParser = new ModuleFE_CSVParser_Class();

package/modules/ModuleFE_CollectionActions.d.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nu-art/ts-common';
+import { ApiDefCaller } from '@nu-art/thunderstorm-shared';
+import { ApiStruct_CollectionActions } from '@nu-art/thunderstorm-shared/collection-actions/api-def';
+declare class ModuleFE_CollectionActions_Class extends Module {
+    readonly upgrade: ApiDefCaller<ApiStruct_CollectionActions['upgrade']>;
+    readonly check: ApiDefCaller<ApiStruct_CollectionActions['check']>;
+    constructor();
+}
+export declare const ModuleFE_CollectionActions: ModuleFE_CollectionActions_Class;
+export {};

package/modules/ModuleFE_CollectionActions.js

@@ -0,0 +1,18 @@
+import { Module } from '@nu-art/ts-common';
+import { ApiDef_CollectionActions } from '@nu-art/thunderstorm-shared/collection-actions/api-def';
+import { apiWithBody } from '../core/typed-api.js';
+class ModuleFE_CollectionActions_Class extends Module {
+    upgrade;
+    check;
+    constructor() {
+        super();
+        this.upgrade = {
+            collections: apiWithBody(ApiDef_CollectionActions.upgrade.collections),
+            all: apiWithBody(ApiDef_CollectionActions.upgrade.all),
+        };
+        this.check = {
+            usage: apiWithBody(ApiDef_CollectionActions.check.usage),
+        };
+    }
+}
+export const ModuleFE_CollectionActions = new ModuleFE_CollectionActions_Class();

package/modules/ModuleFE_ConnectivityModule.d.ts

@@ -0,0 +1,15 @@
+import { Module } from '@nu-art/ts-common';
+export interface OnConnectivityChange {
+    __onConnectivityChange(): void;
+}
+declare class ModuleFE_ConnectivityModule_Class extends Module {
+    private connected;
+    private dispatch_onConnectivityChange;
+    constructor();
+    protected init(): void;
+    isConnected: () => boolean;
+    handleConnectionChange: () => void;
+    private getConnectivityStatus;
+}
+export declare const ModuleFE_ConnectivityModule: ModuleFE_ConnectivityModule_Class;
+export {};

package/modules/ModuleFE_ConnectivityModule.js

@@ -0,0 +1,31 @@
+import { Module } from '@nu-art/ts-common';
+import { ThunderDispatcher } from '../core/thunder-dispatcher.js';
+class ModuleFE_ConnectivityModule_Class extends Module {
+    connected;
+    dispatch_onConnectivityChange = new ThunderDispatcher('__onConnectivityChange');
+    constructor() {
+        super();
+        this.connected = this.getConnectivityStatus();
+    }
+    init() {
+        window.addEventListener('online', this.handleConnectionChange);
+        window.addEventListener('offline', this.handleConnectionChange);
+        // ModuleFE_FirebaseListener.createListener('.info').startListening(snapshot => {
+        // 	if (snapshot.val() === true) {
+        // 		this.logWarningBold(`Connected to Firebase ${__stringify(snapshot.val())}`);
+        // 		// Perform actions when connected
+        // 	} else {
+        // 		this.logWarningBold(`Disconnected from Firebase ${__stringify(snapshot.val())}`);
+        // 		// Handle disconnection
+        // 	}
+        // });
+    }
+    isConnected = () => this.connected;
+    handleConnectionChange = () => {
+        this.connected = this.getConnectivityStatus();
+        this.dispatch_onConnectivityChange.dispatchModule();
+        this.dispatch_onConnectivityChange.dispatchUI();
+    };
+    getConnectivityStatus = () => navigator.onLine;
+}
+export const ModuleFE_ConnectivityModule = new ModuleFE_ConnectivityModule_Class();

package/modules/ModuleFE_ForceUpgrade.d.ts

@@ -0,0 +1,20 @@
+import { Module } from '@nu-art/ts-common';
+import { ApiDefCaller, ApiStruct_ForceUpgrade, UpgradeRequired } from '@nu-art/thunderstorm-shared';
+type Config = {
+    assertVersionUrl: string;
+};
+export interface OnUpgradeRequired {
+    __onUpgradeRequired(response: UpgradeRequired): void;
+}
+export interface OnUpgradeRequired {
+    __onUpgradeRequired(response: UpgradeRequired): void;
+}
+declare class ModuleFE_ForceUpgrade_Class extends Module<Config> implements ApiDefCaller<ApiStruct_ForceUpgrade> {
+    readonly v1: ApiDefCaller<ApiStruct_ForceUpgrade>['v1'];
+    constructor();
+    protected init(): void;
+    compareVersion: () => void;
+    __postInit(): Promise<void>;
+}
+export declare const ModuleFE_ForceUpgrade: ModuleFE_ForceUpgrade_Class;
+export {};