@wavemaker-ai/react-runtime 1.0.0-next.27766

package/runtime-dynamic/shims/next-image.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Shim for next/image in the dynamic preview runtime (non-Next.js).
+ * Renders a standard <img> element with the same props.
+ */
+import React from "react";
+interface ImageSrc {
+    src: string;
+    height?: number;
+    width?: number;
+}
+interface ImageProps {
+    src: string | ImageSrc;
+    alt?: string;
+    width?: number | string;
+    height?: number | string;
+    fill?: boolean;
+    loader?: (params: {
+        src: string;
+        width: number;
+        quality?: number;
+    }) => string;
+    quality?: number;
+    priority?: boolean;
+    loading?: "lazy" | "eager";
+    placeholder?: string;
+    blurDataURL?: string;
+    unoptimized?: boolean;
+    onLoad?: (event: React.SyntheticEvent<HTMLImageElement>) => void;
+    onError?: (event: React.SyntheticEvent<HTMLImageElement>) => void;
+    style?: React.CSSProperties;
+    className?: string;
+    [key: string]: unknown;
+}
+declare function NextImage({ src, alt, width, height, fill, loader: _loader, quality: _quality, priority, loading, placeholder: _placeholder, blurDataURL: _blurDataURL, unoptimized: _unoptimized, ...rest }: ImageProps): import("react/jsx-runtime").JSX.Element;
+export default NextImage;

package/runtime-dynamic/shims/next-image.js

@@ -0,0 +1,89 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+import { jsx } from "react/jsx-runtime";
+function NextImage(_a) {
+  var _b = _a, {
+    src,
+    alt = "",
+    width,
+    height,
+    fill,
+    loader: _loader,
+    quality: _quality,
+    priority,
+    loading,
+    placeholder: _placeholder,
+    blurDataURL: _blurDataURL,
+    unoptimized: _unoptimized
+  } = _b, rest = __objRest(_b, [
+    "src",
+    "alt",
+    "width",
+    "height",
+    "fill",
+    "loader",
+    "quality",
+    "priority",
+    "loading",
+    "placeholder",
+    "blurDataURL",
+    "unoptimized"
+  ]);
+  const imgSrc = typeof src === "object" ? src.src : src;
+  const imgWidth = width != null ? width : typeof src === "object" ? src.width : void 0;
+  const imgHeight = height != null ? height : typeof src === "object" ? src.height : void 0;
+  const resolvedStyle = __spreadValues({}, rest.style || {});
+  if (fill) {
+    resolvedStyle.position = "absolute";
+    resolvedStyle.width = "100%";
+    resolvedStyle.height = "100%";
+    resolvedStyle.objectFit = resolvedStyle.objectFit || "cover";
+  }
+  return (
+    // eslint-disable-next-line @next/next/no-img-element
+    /* @__PURE__ */ jsx(
+      "img",
+      {
+        src: imgSrc,
+        alt,
+        width: fill ? void 0 : imgWidth,
+        height: fill ? void 0 : imgHeight,
+        loading: priority ? "eager" : loading || "lazy",
+        style: resolvedStyle,
+        className: rest.className,
+        onLoad: rest.onLoad,
+        onError: rest.onError
+      }
+    )
+  );
+}
+var next_image_default = NextImage;
+export {
+  next_image_default as default
+};

package/runtime-dynamic/shims/next-link.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Shim for next/link in the dynamic preview runtime (non-Next.js).
+ * Renders a standard <a> element.
+ */
+import React from "react";
+interface LinkHref {
+    pathname?: string;
+    query?: Record<string, string>;
+}
+interface LinkProps {
+    href: string | LinkHref;
+    as?: string;
+    replace?: boolean;
+    scroll?: boolean;
+    shallow?: boolean;
+    prefetch?: boolean;
+    locale?: string;
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+    onClick?: (event: React.MouseEvent<HTMLAnchorElement>) => void;
+    [key: string]: unknown;
+}
+declare function NextLink({ href, children, replace: _replace, scroll: _scroll, shallow: _shallow, prefetch: _prefetch, locale: _locale, as: _as, ...rest }: LinkProps): import("react/jsx-runtime").JSX.Element;
+export default NextLink;

package/runtime-dynamic/shims/next-link.js

@@ -0,0 +1,59 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+import { jsx } from "react/jsx-runtime";
+function NextLink(_a) {
+  var _b = _a, {
+    href,
+    children,
+    replace: _replace,
+    scroll: _scroll,
+    shallow: _shallow,
+    prefetch: _prefetch,
+    locale: _locale,
+    as: _as
+  } = _b, rest = __objRest(_b, [
+    "href",
+    "children",
+    "replace",
+    "scroll",
+    "shallow",
+    "prefetch",
+    "locale",
+    "as"
+  ]);
+  const hrefStr = typeof href === "object" ? `${href.pathname || "/"}${href.query ? "?" + new URLSearchParams(href.query).toString() : ""}` : href;
+  return /* @__PURE__ */ jsx("a", __spreadProps(__spreadValues({ href: hrefStr }, rest), { children }));
+}
+var next_link_default = NextLink;
+export {
+  next_link_default as default
+};

package/runtime-dynamic/shims/next-navigation.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shim for next/navigation in the dynamic preview runtime (non-Next.js).
+ * Uses standard pathname-based routing (browser history API).
+ * Maps shared `react-pages` paths to the preview segment only (this bundle).
+ */
+export declare function useSearchParams(): URLSearchParams;
+export declare function usePathname(): string;
+export declare function useRouter(): {
+    push: (path: string) => void;
+    replace: (path: string) => void;
+    back: () => void;
+    forward: () => void;
+    refresh: () => void;
+    prefetch: () => void;
+};
+export declare function useParams(): {};

package/runtime-dynamic/shims/next-navigation.js

@@ -0,0 +1,35 @@
+import { normalizePreviewPath } from "../preview-path";
+function useSearchParams() {
+  return new URLSearchParams(window.location.search);
+}
+function usePathname() {
+  return window.location.pathname;
+}
+function useRouter() {
+  return {
+    push: (path) => {
+      const normalizedPath = normalizePreviewPath(path);
+      window.history.pushState(null, "", normalizedPath);
+      window.dispatchEvent(new PopStateEvent("popstate"));
+    },
+    replace: (path) => {
+      const normalizedPath = normalizePreviewPath(path);
+      window.history.replaceState(null, "", normalizedPath);
+      window.dispatchEvent(new PopStateEvent("popstate"));
+    },
+    back: () => window.history.back(),
+    forward: () => window.history.forward(),
+    refresh: () => window.location.reload(),
+    prefetch: () => {
+    }
+  };
+}
+function useParams() {
+  return {};
+}
+export {
+  useParams,
+  usePathname,
+  useRouter,
+  useSearchParams
+};

package/runtime-dynamic/utils/index.d.ts

@@ -0,0 +1,11 @@
+export declare function decodeURIComponentSafe(str: string): string;
+export declare function parseJsonSafe(str: string): Record<string, unknown>;
+export declare function getMetaContent(name: string): string;
+/**
+ * Yields control back to the browser's main thread via setTimeout(0),
+ * allowing it to paint frames and handle user input between heavy
+ * compilation phases. Prevents long-task jank (>50ms) that degrades INP.
+ */
+export declare const yieldToMain: () => Promise<void>;
+/** Injects a stylesheet link if the href is not already present. */
+export declare function appendStylesheetLink(href: string): void;

package/runtime-dynamic/utils/index.js

@@ -0,0 +1,38 @@
+function decodeURIComponentSafe(str) {
+  if (!str) return "";
+  try {
+    return decodeURIComponent(str.replace(/\+/g, " "));
+  } catch (e) {
+    return str;
+  }
+}
+function parseJsonSafe(str) {
+  if (!str) return {};
+  try {
+    return JSON.parse(str);
+  } catch (e) {
+    return {};
+  }
+}
+function getMetaContent(name) {
+  const meta = document.querySelector(`meta[name="${name}"]`);
+  return (meta == null ? void 0 : meta.getAttribute("content")) || "";
+}
+const yieldToMain = () => new Promise((resolve) => setTimeout(resolve, 0));
+function appendStylesheetLink(href) {
+  if (!href || document.querySelector(`link[href="${href}"]`)) {
+    return;
+  }
+  const link = document.createElement("link");
+  link.rel = "stylesheet";
+  link.type = "text/css";
+  link.href = href;
+  document.head.appendChild(link);
+}
+export {
+  appendStylesheetLink,
+  decodeURIComponentSafe,
+  getMetaContent,
+  parseJsonSafe,
+  yieldToMain
+};

package/store/bindActions/i18nActions.d.ts

@@ -0,0 +1,7 @@
+export declare const i18nService: {
+    setTimezone: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "i18n/setTimezone">;
+    setAppLocale: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "i18n/setAppLocale">;
+    setDateFormat: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "i18n/setDateFormat">;
+    setTimeFormat: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "i18n/setTimeFormat">;
+    setCurrencyCode: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "i18n/setCurrencyCode">;
+};

package/store/bindActions/i18nActions.js

@@ -0,0 +1,16 @@
+import { bindActionCreators } from "@reduxjs/toolkit";
+import { store } from "..";
+import * as i18nActions from "../slices/i18nSlice";
+const i18nService = bindActionCreators(
+  {
+    setTimezone: i18nActions.setTimezone,
+    setAppLocale: i18nActions.setAppLocale,
+    setDateFormat: i18nActions.setDateFormat,
+    setTimeFormat: i18nActions.setTimeFormat,
+    setCurrencyCode: i18nActions.setCurrencyCode
+  },
+  store.dispatch
+);
+export {
+  i18nService
+};

package/store/index.d.ts

@@ -0,0 +1,18 @@
+import { TypedUseSelectorHook } from "react-redux";
+export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
+    auth: import("@wavemaker-ai/react-runtime/store/slices/authSlice").AuthState;
+    info: import("@wavemaker-ai/react-runtime/store/slices/appConfigSlice").AppConfig;
+    i18n: import("immer").WritableDraft<import("@wavemaker-ai/react-runtime/store/slices/i18nSlice").I18nState>;
+    navigation: import("@wavemaker-ai/react-runtime/store/slices/navigationSlice").NavigationState;
+}, import("redux").UnknownAction, import("@reduxjs/toolkit").Tuple<[import("redux").StoreEnhancer<{
+    dispatch: import("redux-thunk").ThunkDispatch<{
+        auth: import("@wavemaker-ai/react-runtime/store/slices/authSlice").AuthState;
+        info: import("@wavemaker-ai/react-runtime/store/slices/appConfigSlice").AppConfig;
+        i18n: import("immer").WritableDraft<import("@wavemaker-ai/react-runtime/store/slices/i18nSlice").I18nState>;
+        navigation: import("@wavemaker-ai/react-runtime/store/slices/navigationSlice").NavigationState;
+    }, undefined, import("redux").UnknownAction>;
+}>, import("redux").StoreEnhancer]>>;
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;
+export declare const useAppDispatch: () => AppDispatch;
+export declare const useAppSelector: TypedUseSelectorHook<RootState>;

package/store/index.js

@@ -0,0 +1,34 @@
+import { combineReducers, configureStore } from "@reduxjs/toolkit";
+import { setupListeners } from "@reduxjs/toolkit/query";
+import authReducer from "./slices/authSlice";
+import appConfigReducer from "./slices/appConfigSlice";
+import { useDispatch, useSelector } from "react-redux";
+import i18nReducer from "./slices/i18nSlice";
+import navigationReducer from "./slices/navigationSlice";
+import { pendingTabNavigationIntentMiddleware } from "./middleware/pendingTabNavigationIntentMiddleware";
+const rootReducer = combineReducers({
+  auth: authReducer,
+  info: appConfigReducer,
+  i18n: i18nReducer,
+  navigation: navigationReducer
+});
+const store = configureStore({
+  reducer: rootReducer,
+  middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+    serializableCheck: {
+      ignoredActions: ["auth/loadSecurityInfo/fulfilled"],
+      ignoredActionPaths: ["meta.arg", "payload.config", "payload.request"],
+      ignoredPaths: ["auth.securityConfig"]
+    }
+  }).concat(pendingTabNavigationIntentMiddleware)
+});
+if (typeof window !== "undefined") {
+  setupListeners(store.dispatch);
+}
+const useAppDispatch = useDispatch;
+const useAppSelector = useSelector;
+export {
+  store,
+  useAppDispatch,
+  useAppSelector
+};

package/store/middleware/navigationMiddleware.d.ts

@@ -0,0 +1,10 @@
+import { Middleware } from "redux";
+export interface RouterLike {
+    push: (path: string) => void;
+    replace: (path: string) => void;
+    back: () => void;
+    forward: () => void;
+}
+export declare const setRouter: (routerInstance: RouterLike) => void;
+export declare const navigationMiddleware: Middleware;
+export declare const getRouterInstance: () => RouterLike | null;

package/store/middleware/navigationMiddleware.js

@@ -0,0 +1,28 @@
+import {
+  loadSecurityInfo,
+  setPageLoading
+} from "../slices/authSlice";
+import { getActiveRoutingBasePath } from "../../core/constants";
+let router = null;
+const setRouter = (routerInstance) => {
+  router = routerInstance;
+};
+const navigationMiddleware = (store) => (next) => async (action) => {
+  var _a, _b;
+  const result = next(action);
+  if (loadSecurityInfo.rejected.match(action)) {
+    const state = store.getState();
+    const loginPage = ((_b = (_a = state.auth.securityConfig) == null ? void 0 : _a.loginConfig) == null ? void 0 : _b.pageName) || "Login";
+    if (router) {
+      store.dispatch(setPageLoading(false));
+      router.push(`/${getActiveRoutingBasePath()}/${loginPage}`);
+    }
+  }
+  return result;
+};
+const getRouterInstance = () => router;
+export {
+  getRouterInstance,
+  navigationMiddleware,
+  setRouter
+};

package/store/middleware/pendingTabNavigationIntentMiddleware.d.ts

@@ -0,0 +1,6 @@
+import type { Middleware } from "@reduxjs/toolkit";
+/**
+ * Keeps pending-tab navigation intent in module scope for components that render
+ * outside a react-redux Provider while navigation still uses the app store.
+ */
+export declare const pendingTabNavigationIntentMiddleware: Middleware;

package/store/middleware/pendingTabNavigationIntentMiddleware.js

@@ -0,0 +1,20 @@
+import {
+  clearPendingTabSelection,
+  setPendingTabSelection
+} from "../slices/navigationSlice";
+import {
+  applyPendingTabNavigationIntent,
+  clearPendingTabNavigationIntent
+} from "../../utils/pending-tab-navigation-intent";
+const pendingTabNavigationIntentMiddleware = () => (next) => (action) => {
+  const result = next(action);
+  if (setPendingTabSelection.match(action)) {
+    applyPendingTabNavigationIntent(action.payload);
+  } else if (clearPendingTabSelection.match(action)) {
+    clearPendingTabNavigationIntent();
+  }
+  return result;
+};
+export {
+  pendingTabNavigationIntentMiddleware
+};

package/store/slices/appConfigSlice.d.ts

@@ -0,0 +1,21 @@
+export interface AppConfig {
+    [key: string]: any;
+    appVariables?: any;
+    appConfig?: any;
+}
+export declare const getServiceDefinitions: import("@reduxjs/toolkit").AsyncThunk<any, string, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const getPrefabDefinitions: import("@reduxjs/toolkit").AsyncThunk<{
+    serviceDefs: any;
+    baseUrl: string;
+    pages: any[];
+}, {
+    prefabName: string;
+    baseUrl: string;
+    pages?: any[];
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const updateConfig: import("@reduxjs/toolkit").ActionCreatorWithNonInferrablePayload<"appConfig/updateConfig">, addPrefab: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<{
+    prefabName: string;
+    data: any;
+}, "appConfig/addPrefab">;
+declare const _default: import("redux").Reducer<AppConfig>;
+export default _default;

package/store/slices/appConfigSlice.js

@@ -0,0 +1,76 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import { createSlice, createAsyncThunk } from "@reduxjs/toolkit";
+import axios from "axios";
+import { resolveBasePath } from "../util/resolve-path";
+const initialState = {
+  appVariables: {},
+  appConfig: {},
+  prefabs: {}
+};
+const getServiceDefinitions = createAsyncThunk(
+  "appConfig/getServiceDefinitions",
+  async (baseUrl, { dispatch, rejectWithValue }) => {
+    try {
+      const url = `${resolveBasePath(baseUrl)}/services/servicedefs${baseUrl ? "" : ".json"}`;
+      const response = await axios.get(url);
+      const data = (response == null ? void 0 : response.data) || {};
+      const serviceDefinitions = (data == null ? void 0 : data.serviceDefs) || {};
+      dispatch(updateConfig(data));
+      return serviceDefinitions;
+    } catch (error) {
+      return rejectWithValue("Failed to fetch service definitions");
+    }
+  }
+);
+const getPrefabDefinitions = createAsyncThunk(
+  "appConfig/getPrefabDefinitions",
+  async ({ prefabName, baseUrl, pages }, { dispatch, rejectWithValue }) => {
+    var _a;
+    try {
+      const useRootServicedefs = !prefabName || prefabName === "__self__";
+      const url = useRootServicedefs ? `${resolveBasePath(baseUrl)}/services/servicedefs${baseUrl ? "" : ".json"}` : `${resolveBasePath(baseUrl)}/services/prefabs/${prefabName}/servicedefs${baseUrl ? "" : ".json"}`;
+      const response = await axios.get(url);
+      const data = { serviceDefs: ((_a = response == null ? void 0 : response.data) == null ? void 0 : _a.serviceDefs) || {}, baseUrl: url, pages };
+      dispatch(addPrefab({ prefabName, data }));
+      return data;
+    } catch (error) {
+      return rejectWithValue("Failed to fetch prefab definitions");
+    }
+  }
+);
+const appConfigSlice = createSlice({
+  name: "appConfig",
+  initialState,
+  reducers: {
+    updateConfig: (state, action) => {
+      return __spreadValues(__spreadValues({}, state), action.payload);
+    },
+    addPrefab: (state, action) => {
+      state.prefabs[action.payload.prefabName] = action.payload.data;
+    }
+  }
+});
+const { updateConfig, addPrefab } = appConfigSlice.actions;
+var appConfigSlice_default = appConfigSlice.reducer;
+export {
+  addPrefab,
+  appConfigSlice_default as default,
+  getPrefabDefinitions,
+  getServiceDefinitions,
+  updateConfig
+};

package/store/slices/authSlice.d.ts

@@ -0,0 +1,54 @@
+export declare const XSRF_COOKIE_NAME: string;
+export declare const XSRF_HEADER_NAME: string;
+export declare const SESSION = "SESSION";
+export interface LoggedInUserConfig {
+    isAuthenticated: boolean;
+    isSecurityEnabled: boolean;
+    roles: Array<string>;
+    name: string;
+    id: string;
+    tenantId: string;
+    userAttributes: any;
+    landingPage: string;
+}
+export declare enum USER_ROLE {
+    EVERYONE = "Everyone",
+    ANONYMOUS = "Anonymous",
+    AUTHENTICATED = "Authenticated"
+}
+export interface LoginOptions {
+    baseURL: string;
+    formData: Record<string, string>;
+    useDefaultSuccessHandler?: boolean;
+}
+export interface AuthState {
+    isLoggedIn: boolean;
+    isPageLoading: boolean;
+    loggedInUser: LoggedInUserConfig | null;
+    securityConfig: any;
+    token: string | null;
+    landingPage: string;
+    error: string | null;
+}
+export declare const defaultUserState: LoggedInUserConfig;
+export declare const loadSecurityInfo: import("@reduxjs/toolkit").AsyncThunk<any, string, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const login: import("@reduxjs/toolkit").AsyncThunk<any, LoginOptions, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const logout: import("@reduxjs/toolkit").AsyncThunk<any, any, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const canAccessPage: import("@reduxjs/toolkit").AsyncThunk<any, {
+    pageName: string;
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const checkAccess: import("@reduxjs/toolkit").AsyncThunk<any, {
+    name: string;
+    type: "PAGE" | "PARTIAL" | "PREFAB";
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const navigateToLandingPage: import("@reduxjs/toolkit").AsyncThunk<void, {
+    baseUrl: string;
+    pageName: string;
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const redirectToLogin: import("@reduxjs/toolkit").AsyncThunk<void, {
+    redirectTo?: string;
+    securityConfig?: any;
+}, import("@reduxjs/toolkit").AsyncThunkConfig>;
+export declare const setIsLoggedIn: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, "auth/setIsLoggedIn">, setLoggedInUser: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<LoggedInUserConfig, "auth/setLoggedInUser">, setSecurityConfig: import("@reduxjs/toolkit").ActionCreatorWithPayload<any, "auth/setSecurityConfig">, setToken: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<string, "auth/setToken">, setLandingPage: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<string, "auth/setLandingPage">, setPageLoading: import("@reduxjs/toolkit").ActionCreatorWithOptionalPayload<boolean, "auth/setPageLoading">, clearError: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"auth/clearError">;
+declare const _default: import("redux").Reducer<AuthState>;
+export default _default;