@nu-art/thunderstorm-frontend 0.400.5

package/modules/routing/ModuleFE_Routing.d.ts

@@ -0,0 +1,30 @@
+import { Module, RouteParams } from '@nu-art/ts-common';
+import * as React from 'react';
+import { RoutePath } from './route.js';
+import { QueryParams } from '@nu-art/thunderstorm-shared';
+declare class ModuleFE_Routing_Class extends Module<{}> {
+    private readonly routes;
+    private readonly ordinalRoutes;
+    private readonly createNavLinkNode;
+    private readonly createRouteNode;
+    private readonly createLinkNode;
+    constructor();
+    init(): void;
+    clearRoutes(): void;
+    addRoute(key: string, route: string, component: React.ComponentClass<any, any> | string): RoutePath;
+    getRoute(key: string): RoutePath;
+    getPath(key: string): string;
+    goToRoute(key: string, params?: RouteParams): void;
+    redirect(key: string): import("react/jsx-runtime").JSX.Element;
+    getMyRouteKey: () => string | undefined;
+    getNavLinks(keys: string[]): React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
+    getNavLink(key: string): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+    getLink(key: string): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+    getRoutesMap(keys?: string[]): import("react/jsx-runtime").JSX.Element;
+    getCurrentUrl: () => string;
+    private getEncodedQueryParams;
+    getSearch(): QueryParams;
+    goToUrl: (url: string) => string;
+}
+export declare const ModuleFE_Routing: ModuleFE_Routing_Class;
+export {};

package/modules/routing/ModuleFE_Routing.js

@@ -0,0 +1,122 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * 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.
+ */
+import { _keys, addItemToArray, BadImplementationException, composeQueryParams, Module } from '@nu-art/ts-common';
+import { defaultLinkNode, defaultNavLinkNode, defaultRouteNode, RoutePath } from './route.js';
+import { ModuleFE_BrowserHistory } from '../ModuleFE_BrowserHistory.js';
+import { Navigate, Routes } from 'react-router-dom';
+class ModuleFE_Routing_Class extends Module {
+    routes = {};
+    ordinalRoutes = [];
+    createNavLinkNode;
+    createRouteNode;
+    createLinkNode;
+    constructor() {
+        super();
+        this.createNavLinkNode = defaultNavLinkNode;
+        this.createLinkNode = defaultLinkNode;
+        this.createRouteNode = defaultRouteNode;
+    }
+    init() {
+    }
+    clearRoutes() {
+        for (const item of this.ordinalRoutes) {
+            delete this.routes[item];
+        }
+        this.ordinalRoutes.splice(0);
+    }
+    addRoute(key, route, component) {
+        const previousRoute = this.routes[key];
+        if (previousRoute)
+            throw new BadImplementationException(`Route key '${key}' MUST be unique!!\n  Found two routes with matching key: '${route}' && '${previousRoute.path}'`);
+        addItemToArray(this.ordinalRoutes, key);
+        return this.routes[key] = new RoutePath(key, route, component);
+    }
+    getRoute(key) {
+        const route = this.routes[key];
+        if (!route)
+            throw new BadImplementationException(`No Route for key '${key}'... Did you forget to add it??`);
+        return route;
+    }
+    getPath(key) {
+        return this.getRoute(key).path;
+    }
+    goToRoute(key, params) {
+        const pathname = this.getPath(key);
+        const search = composeQueryParams(params);
+        ModuleFE_BrowserHistory.push({ pathname, search });
+    }
+    redirect(key) {
+        return _jsx(Navigate, { to: ModuleFE_Routing.getPath(key) });
+    }
+    getMyRouteKey = () => Object.keys(this.routes).find(key => this.routes[key].path === ModuleFE_BrowserHistory.getCurrent().pathname);
+    // need to figure out how to create parameterized urls from this call !!
+    getNavLinks(keys) {
+        return keys.map(key => this.getRoute(key)).filter(route => route.visible && route.visible()).map(route => this.createNavLinkNode(route));
+    }
+    getNavLink(key) {
+        return this.createNavLinkNode(this.getRoute(key));
+    }
+    getLink(key) {
+        return this.createLinkNode(this.getRoute(key));
+    }
+    getRoutesMap(keys) {
+        return _jsx(Routes, { children: (keys || this.ordinalRoutes).map(key => this.createRouteNode(this.getRoute(key))) });
+    }
+    getCurrentUrl = () => window.location.href;
+    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] };
+        }).reduce((toRet, param) => {
+            if (param.key && param.value)
+                toRet[param.key] = param.value;
+            return toRet;
+        }, queryParams);
+    };
+    getSearch() {
+        const params = this.getEncodedQueryParams();
+        _keys(params).forEach(key => {
+            const value = `${params[key]}`;
+            if (!value) {
+                delete params[key];
+                return;
+            }
+            params[key] = decodeURIComponent(value);
+        });
+        return params;
+    }
+    goToUrl = (url) => window.location.href = url;
+}
+export const ModuleFE_Routing = new ModuleFE_Routing_Class();

package/modules/routing/ModuleFE_RoutingV2.d.ts

@@ -0,0 +1,25 @@
+import { NavigateFunction, NavLinkProps } from 'react-router-dom';
+import { TS_Route } from './types.js';
+import { Module } from '@nu-art/ts-common';
+import { QueryParams } from '@nu-art/thunderstorm-shared';
+declare class ModuleFE_RoutingV2_Class extends Module<{}> {
+    private routesMapByKey;
+    private routesMapByPath;
+    private navigate;
+    goToRoute<P extends QueryParams>(route: TS_Route<P>, params?: Partial<P>): void;
+    redirect<P extends QueryParams>(route: TS_Route<P>, params?: Partial<P>): import("react/jsx-runtime").JSX.Element;
+    generateRoutes(rootRoute: TS_Route): import("react/jsx-runtime").JSX.Element;
+    buildRouteMap(route: TS_Route, _path?: string): void;
+    private routeBuilder;
+    private resolveRouteComponent;
+    getRouteByKey(routeKey: string): TS_Route | undefined;
+    getFullPath(routeKey: string): string;
+    getCurrentRouteKey(): TS_Route;
+    setNavigate(navigate: NavigateFunction): void;
+}
+export declare const TS_NavLink: (props: {
+    route: TS_Route;
+    ignoreClickOnSameRoute?: boolean;
+} & Partial<NavLinkProps>) => import("react/jsx-runtime").JSX.Element;
+export declare const ModuleFE_RoutingV2: ModuleFE_RoutingV2_Class;
+export {};

package/modules/routing/ModuleFE_RoutingV2.js

@@ -0,0 +1,143 @@
+import { createElement as _createElement } from "react";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { BrowserRouter, Navigate, NavLink, Route, Routes } from 'react-router-dom';
+import { BadImplementationException, composeUrl, Module, removeItemFromArray } from '@nu-art/ts-common';
+import { LocationChangeListener } from './LocationChangeListener.js';
+import { mouseEventHandler, stopPropagation } from '../../utils/tools.js';
+import { AwaitModules } from '../../components/AwaitModules/AwaitModules.js';
+import { AwaitSync } from '../../components/AwaitSync/AwaitSync.js';
+class ModuleFE_RoutingV2_Class extends Module {
+    // ######################## Inner Data ########################
+    routesMapByKey = {};
+    routesMapByPath = {};
+    navigate;
+    // ######################## Public Functions ########################
+    goToRoute(route, params) {
+        const fullPath = this.getFullPath(route.key);
+        try {
+            const url = composeUrl(fullPath, params, window.location.hash);
+            if (window.location.href === url)
+                return this.logWarning(`attempting to set same route: ${url}`);
+            this.navigate(url);
+        }
+        catch (e) {
+            this.logError(`cannot resolve route for route: `, route, e);
+            throw e;
+        }
+    }
+    redirect(route, params) {
+        const url = composeUrl(this.getFullPath(route.key), params);
+        return _jsx(Navigate, { to: url });
+    }
+    generateRoutes(rootRoute) {
+        // This needs to be a component in order to be build the routes on rendering after modules are awaited
+        this.buildRouteMap(rootRoute);
+        const RoutesRenderer = () => _jsx(Routes, { children: this.routeBuilder(rootRoute) });
+        return _jsxs(BrowserRouter, { children: [_jsx(LocationChangeListener, {}), _jsx(RoutesRenderer, {})] });
+    }
+    buildRouteMap(route, _path = '') {
+        const path = `${_path}/`;
+        this.routesMapByKey[route.key] = { route, fullPath: _path };
+        this.routesMapByPath[_path] = route;
+        route.children?.map(route => this.buildRouteMap(route, `${path}${route.path}`));
+    }
+    routeBuilder = (route) => {
+        this.logDebug(`building route for: ${route.key}`);
+        const path = this.routesMapByKey[route.key].fullPath;
+        const routes = route.children || [];
+        const indicesRoutes = routes?.filter(route => route.index);
+        if (indicesRoutes && indicesRoutes.length > 1)
+            throw new BadImplementationException(`more than one index route found in ${path}: ${indicesRoutes.map(r => r.key).join(', ')}`);
+        const indexRoute = indicesRoutes?.[0];
+        let _indexRoute;
+        if (indexRoute) {
+            const Component = this.resolveRouteComponent(indexRoute);
+            if (indexRoute.path) {
+                this.logDebug(`index route redirect to path: ${path}/${indexRoute.path}`);
+                // force redirect to a different route
+                _indexRoute = _jsx(Route, { index: true, element: _jsx(Navigate, { to: `${path}/${indexRoute.path}` }) });
+            }
+            else {
+                // default index route renderer
+                this.logDebug(`index route render component: ${path}/${indexRoute.path}`);
+                _indexRoute = _jsx(Route, { index: true, Component: Component, element: indexRoute.element });
+                removeItemFromArray(routes, indexRoute);
+            }
+        }
+        if (route.fallback)
+            this.logDebug(`fallback: ${path}`);
+        const children = route.children?.filter(route => {
+            return route.enabled?.() ?? true;
+        }) ?? [];
+        const Component = this.resolveRouteComponent(route);
+        return _jsxs(Route, { path: route.path, Component: Component, element: route.element, children: [_indexRoute, children.map(route => this.routeBuilder(route))] }, route.key);
+    };
+    resolveRouteComponent = (route) => {
+        if (!route.Component)
+            return undefined;
+        const shouldAwaitModules = !!route.modulesToAwait;
+        const shouldAwaitSync = !!route.awaitSync;
+        //No awaiting of any type
+        if (!shouldAwaitModules && !shouldAwaitSync)
+            return route.Component;
+        //Awaiting both modules and sync
+        if (shouldAwaitModules && shouldAwaitSync) {
+            if (route.Component.prototype?.render) {
+                const Component = route.Component;
+                return () => _jsx(AwaitSync, { customLoader: route.awaitSyncLoader, children: _jsx(AwaitModules, { modules: route.modulesToAwait, customLoader: route.awaitModulesLoader, children: _jsx(Component, {}) }) });
+            }
+            const component = route.Component;
+            return () => _jsx(AwaitSync, { customLoader: route.awaitSyncLoader, children: _jsx(AwaitModules, { modules: route.modulesToAwait, customLoader: route.awaitModulesLoader, children: component({}) }) });
+        }
+        //Awaiting only modules
+        if (shouldAwaitModules && !shouldAwaitSync) {
+            //route.Component is a class component
+            if (route.Component.prototype?.render) {
+                const Component = route.Component;
+                return () => _jsx(AwaitModules, { modules: route.modulesToAwait, customLoader: route.awaitModulesLoader, children: _jsx(Component, {}) });
+            }
+            //route.Component is a function component
+            const component = route.Component;
+            return () => _jsx(AwaitModules, { modules: route.modulesToAwait, customLoader: route.awaitModulesLoader, children: component({}) });
+        }
+        //Awaiting only sync
+        if (shouldAwaitModules && !shouldAwaitSync) {
+            if (route.Component.prototype.render) {
+                const Component = route.Component;
+                return () => _jsx(AwaitSync, { customLoader: route.awaitSyncLoader, children: _jsx(Component, {}) });
+            }
+            //route.Component is a function component
+            const component = route.Component;
+            return () => _jsx(AwaitSync, { customLoader: route.awaitSyncLoader, children: component({}) });
+        }
+    };
+    getRouteByKey(routeKey) {
+        return this.routesMapByKey[routeKey]?.route;
+    }
+    getFullPath(routeKey) {
+        const route = this.routesMapByKey[routeKey];
+        if (!route)
+            throw new BadImplementationException(`Cannot find full path for route key: ${routeKey}`);
+        return route.fullPath;
+    }
+    getCurrentRouteKey() {
+        return this.routesMapByPath[window.location.pathname];
+    }
+    setNavigate(navigate) {
+        this.navigate = navigate;
+    }
+}
+export const TS_NavLink = (props) => {
+    const { route, children, ignoreClickOnSameRoute, ..._props } = props;
+    const fullPath = ModuleFE_RoutingV2.getFullPath(route.key);
+    if (!fullPath)
+        throw new BadImplementationException(`Route with key ${route.key} is not defined in routing module`);
+    return _createElement(NavLink, { ..._props, to: fullPath, key: route.key, onClick: e => {
+            const pathname = window.location.pathname;
+            if (props.ignoreClickOnSameRoute && pathname === fullPath)
+                stopPropagation(e);
+        }, onMouseUp: e => mouseEventHandler(e, {
+            middle: () => window.open(fullPath, '_blank'),
+        }) }, children);
+};
+export const ModuleFE_RoutingV2 = new ModuleFE_RoutingV2_Class();

package/modules/routing/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './LocationChangeListener.js';
+export * from './route.js';
+export * from './ModuleFE_Routing.js';
+export * from './ModuleFE_RoutingV2.js';

package/modules/routing/index.js

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './LocationChangeListener.js';
+export * from './route.js';
+export * from './ModuleFE_Routing.js';
+export * from './ModuleFE_RoutingV2.js';

package/modules/routing/route.d.ts

@@ -0,0 +1,22 @@
+import { RouteParams } from '@nu-art/ts-common';
+import * as React from 'react';
+export declare class RoutePath {
+    key: string;
+    path: string;
+    exact: boolean;
+    component: React.ComponentClass | string;
+    logMessage?: string;
+    label?: React.ElementType | string;
+    visible: () => boolean;
+    enabled?: () => boolean;
+    constructor(key: string, route: string, component: React.ComponentClass | string);
+    setLogMessage(logMessage: string): this;
+    setLabel(label: React.ElementType | string): this;
+    setVisible(visible: () => boolean): this;
+    setEnabled(enabled: () => boolean): this;
+    setExact(exact: boolean): this;
+    compose(params?: RouteParams): string;
+}
+export declare const defaultNavLinkNode: (route: RoutePath) => React.ReactElement;
+export declare const defaultLinkNode: (route: RoutePath, node?: React.ReactNode) => React.ReactElement;
+export declare const defaultRouteNode: (route: RoutePath) => React.ReactElement;

package/modules/routing/route.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * 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.
+ */
+import { composeUrl } from '@nu-art/ts-common';
+import { Link, NavLink, Route } from 'react-router-dom';
+export class RoutePath {
+    key;
+    path;
+    exact = false;
+    component;
+    logMessage;
+    label;
+    visible = () => !!this.label;
+    enabled;
+    constructor(key, route, component) {
+        this.key = key;
+        this.path = route;
+        this.component = component;
+    }
+    setLogMessage(logMessage) {
+        // @ts-ignore
+        this.logMessage = logMessage;
+        return this;
+    }
+    setLabel(label) {
+        // @ts-ignore
+        this.label = label;
+        return this;
+    }
+    setVisible(visible) {
+        // @ts-ignore
+        this.visible = visible;
+        return this;
+    }
+    setEnabled(enabled) {
+        // @ts-ignore
+        this.enabled = enabled;
+        return this;
+    }
+    setExact(exact) {
+        // @ts-ignore
+        this.exact = exact;
+        return this;
+    }
+    compose(params) {
+        return composeUrl(this.path, params);
+    }
+}
+const getNavStyles = (props) => {
+    return {
+        color: props.isActive ? 'blue' : undefined,
+    };
+};
+export const defaultNavLinkNode = (route) => {
+    return _jsx(NavLink, { to: route.path, style: getNavStyles, children: route.label }, route.key);
+};
+export const defaultLinkNode = (route, node) => {
+    return _jsx(Link, { to: route.path, children: node || route.label || route.key }, route.key);
+};
+export const defaultRouteNode = (route) => {
+    // if (typeof route.component === 'string')
+    // 	return <ReactEntryComponentInjector src={route.component}/>;
+    const Component = route.component;
+    return _jsx(Route, { path: route.path, element: _jsx(Component, {}) }, route.key);
+};

package/modules/routing/types.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { QueryParams } from '../../shared.js';
+import { ResolvableContent } from '@nu-art/ts-common';
+import { ModuleFE_BaseDB } from '../db-api-gen/ModuleFE_BaseDB.js';
+import { AwaitModule_LoaderProps } from '../../components/AwaitModules/AwaitModules.js';
+export type TS_Route<T extends QueryParams = QueryParams> = {
+    key: string;
+    path: string;
+    enabled?: () => boolean;
+    element?: React.ReactNode;
+    Component?: React.ComponentType<any>;
+    paramKeys?: (keyof T)[];
+    fallback?: boolean;
+    index?: boolean;
+    children?: TS_Route<any>[];
+    modulesToAwait?: ResolvableContent<(ModuleFE_BaseDB<any, any>)[]>;
+    awaitModulesLoader?: ResolvableContent<React.ReactNode, [AwaitModule_LoaderProps]>;
+    awaitSync?: boolean;
+    awaitSyncLoader?: ResolvableContent<React.ReactNode>;
+};

package/modules/routing/types.js

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

package/modules/sync-env/ModuleFE_SyncEnvV2.d.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nu-art/ts-common';
+import { ApiDefCaller, ApiStruct_SyncEnv } from '../../shared.js';
+declare class ModuleFE_SyncEnvV2_Class extends Module {
+    readonly vv1: ApiDefCaller<ApiStruct_SyncEnv>['vv1'];
+    constructor();
+}
+export declare const ModuleFE_SyncEnvV2: ModuleFE_SyncEnvV2_Class;
+export {};

package/modules/sync-env/ModuleFE_SyncEnvV2.js

@@ -0,0 +1,18 @@
+import { Module } from '@nu-art/ts-common';
+import { ApiDef_SyncEnv } from '../../shared.js';
+import { apiWithBody, apiWithQuery } from '../../core/typed-api.js';
+class ModuleFE_SyncEnvV2_Class extends Module {
+    vv1;
+    constructor() {
+        super();
+        this.vv1 = {
+            getLatestBackup: apiWithQuery(ApiDef_SyncEnv.vv1.getLatestBackup),
+            syncToEnv: apiWithBody(ApiDef_SyncEnv.vv1.syncToEnv),
+            syncFromEnvBackup: apiWithBody(ApiDef_SyncEnv.vv1.syncFromEnvBackup),
+            createBackup: apiWithQuery(ApiDef_SyncEnv.vv1.createBackup),
+            fetchBackupMetadata: apiWithQuery(ApiDef_SyncEnv.vv1.fetchBackupMetadata),
+            syncFirebaseFromBackup: apiWithQuery(ApiDef_SyncEnv.vv1.syncFirebaseFromBackup)
+        };
+    }
+}
+export const ModuleFE_SyncEnvV2 = new ModuleFE_SyncEnvV2_Class();

package/modules/sync-manager/ModuleFE_SyncManager.d.ts

@@ -0,0 +1,59 @@
+import { Module, ResolvableContent } from '@nu-art/ts-common';
+import { SyncDataFirebaseState } from '@nu-art/thunderstorm-shared/sync-manager/types';
+import { OnConnectivityChange } from '../ModuleFE_ConnectivityModule.js';
+import { ModuleFE_BaseApi } from '../db-api-gen/ModuleFE_BaseApi.js';
+import { SyncManagerAPI_SmartSync } from '@nu-art/thunderstorm-shared/sync-manager/apis';
+export interface PermissibleModulesUpdated {
+    __onPermissibleModulesUpdated: () => void;
+}
+export declare const Default_SyncManagerNodePath = "/state/ModuleBE_SyncManager/syncData";
+export declare class ModuleFE_SyncManager_Class extends Module implements OnConnectivityChange {
+    __onConnectivityChange(): Promise<void>;
+    private syncedModules;
+    private readonly currentlySyncingModules;
+    private syncFirebaseListener?;
+    private outOfSyncCollections;
+    private syncing?;
+    private pendingSync?;
+    private cancelledSyncs;
+    private cleanIDBOnFullSync;
+    private syncManagerNodePath;
+    private smartSyncApiUrl;
+    private currentSyncData;
+    private _smartSyncCompleted?;
+    private _onSyncDataChanged?;
+    private _debounceTimeout;
+    private _debounceMaxTimeout;
+    private syncDebouncer?;
+    private syncQueue;
+    constructor();
+    setShouldCleanIDBOnFullSync: (cleanIDBOnFullSync: boolean) => void;
+    getPermissibleModuleNames: () => string[];
+    getCurrentlySyncingModules: () => ModuleFE_BaseApi<any, object, object & import("../../core/db-api-gen/db-def.js").DBApiFEConfig<any>>[];
+    cancelSync: () => void;
+    private getModulesToSync;
+    private getLocalSyncData;
+    private smartSync;
+    private clearSyncingStatus;
+    private debounceSyncImpl;
+    /**
+     * Perform no sync, delta sync and full sync on modules. Intention is to get all modules to DataStatus "ContainsData".
+     */
+    onSmartSyncCompleted: (response: SyncManagerAPI_SmartSync["response"]) => Promise<void>;
+    private performSync;
+    private performNoSync;
+    private performDeltaSync;
+    private performFullSync;
+    private generateSyncRequestId;
+    private removeFromCancelledSyncs;
+    startListening(): void;
+    stopListening(): void;
+    private onSyncDataChanged;
+    setNodeContext: (nodeContextResolver: ResolvableContent<string>) => ResolvableContent<string>;
+    setSmartSyncUrl: (baseUrlResolver: ResolvableContent<string | undefined>) => ResolvableContent<string | undefined>;
+    setOnSyncCompleted: (smartSyncCompleted: (syncData: SyncDataFirebaseState) => void) => (syncData: SyncDataFirebaseState) => void;
+    setOnSyncDataChanged: (onSyncDataChanged: (syncData?: SyncDataFirebaseState) => void) => (syncData?: SyncDataFirebaseState) => void;
+    setDebounceTimeout: (debounceTimeout: number) => number;
+    setDebounceMaxTimeout: (debounceTimeout: number) => number;
+}
+export declare const ModuleFE_SyncManager: ModuleFE_SyncManager_Class;