@elliemae/pui-app-sdk 6.0.0-alpha.3 → 6.0.0-alpha.4

package/dist/esm/view/tests/travelhub/latest/manifest.json

@@ -0,0 +1,6 @@
+{
+  "app.js": "latest/app.checksum.js",
+  "landing.js": "latest/landing.checksum.js",
+  "app.css": "latest/app.checksum.css",
+  "landing.css": "latest/landing.checksum.css"
+}

package/dist/esm/view/tests/utils.js

@@ -0,0 +1,33 @@
+import { readFile } from "fs/promises";
+import path from "node:path";
+import { logger as puiLogger, Console } from "@elliemae/pui-diagnostics";
+const getMajorMinorVersion = (version) => version.split(".").slice(0, 2).join(".");
+const sendJS = async (res, ctx, filePath) => {
+  const fileContent = await readFile(path.join(__dirname, filePath), "utf-8");
+  return res.once(
+    ctx.status(200),
+    ctx.set("Content-Type", "application/javascript"),
+    ctx.body(fileContent)
+  );
+};
+const sendJSText = async (res, ctx, fileContent) => res.once(
+  ctx.status(200),
+  ctx.set("Content-Type", "application/javascript"),
+  ctx.body(fileContent)
+);
+const releaseJSThread = () => new Promise((resolve) => {
+  setTimeout(resolve, 0);
+});
+const logger = puiLogger({
+  transport: Console(),
+  index: "microfe",
+  team: "ui platform",
+  appName: "MicroFE Tests"
+});
+export {
+  getMajorMinorVersion,
+  logger,
+  releaseJSThread,
+  sendJS,
+  sendJSText
+};

package/dist/esm/view/wait-message/index.js

@@ -9,6 +9,7 @@ import {
   waitStartEvent,
   waitEndEvent
 } from "../../analytics/user-wait-event.js";
+import { lrTrack } from "../../utils/logrocket.js";
 const StyledCircularIndicator = styled(DSCircularIndeterminateIndicator)`
   position: absolute;
   left: 50%;
@@ -37,6 +38,7 @@ const WaitMessage = memo(
           if (isOpen && ref.current) {
             setShow(true);
             waitStartEvent();
+            lrTrack("wait-spinner-start");
           }
         },
         delay ? 1e3 : 0
@@ -44,6 +46,7 @@ const WaitMessage = memo(
       if (!isOpen) {
         setShow(false);
         waitEndEvent();
+        lrTrack("wait-spinner-end");
       }
     }, [delay, isOpen]);
     useHTMLWaitMessage(isOpen !== null);

package/dist/types/lib/analytics/index.d.ts

@@ -1,10 +1,22 @@
 import { BAEvent } from '@elliemae/pui-micro-frontend-base';
 /**
- * Sends business analytics event
- * @param root0
- * @param root0.data
- * @param root0.self
- * @deprecated use Analytics.sendBAEvent scripting object method instead
+ * Sends a business analytics event to Google Tag Manager data layer.
+ * Can send events to the host app or handle locally.
+ * @param config - Event configuration
+ * @param config.data - The analytics event data
+ * @param config.self - If true, sends to self; if false, sends to host app (default: true)
+ * @deprecated Use Analytics.sendBAEvent scripting object method instead
+ * @example
+ * ```typescript
+ * sendBAEvent({
+ *   data: {
+ *     eventName: 'button_click',
+ *     eventCategory: 'user_interaction',
+ *     eventData: { buttonId: 'submit' }
+ *   },
+ *   self: true
+ * });
+ * ```
  */
 export declare const sendBAEvent: ({ data, self, }: {
     data: BAEvent;

package/dist/types/lib/api/auth/index.d.ts

@@ -33,11 +33,13 @@ export interface IntrospectionResponse extends AxiosResponse {
         encompass_instance_id: string;
         user_name: string;
         bearer_token: string;
+        user_key: string;
     };
 }
 export declare const introspectToken: ({ clientId, accessToken, }: IntrospectRequestParams) => Promise<{
     encompass_instance_id: string;
     user_name: string;
     bearer_token: string;
+    user_key: string;
 }>;
 export {};

package/dist/types/lib/api/users/index.d.ts

@@ -1,5 +1,6 @@
 interface UsersRequestParams {
     userName: string;
+    isConsumerUser: boolean;
 }
-export declare const getUser: ({ userName }: UsersRequestParams) => Promise<Record<string, unknown>>;
+export declare const getUser: ({ userName, isConsumerUser, }: UsersRequestParams) => Promise<Record<string, unknown>>;
 export {};

package/dist/types/lib/communication/http-client/baseQuery.d.ts

@@ -8,7 +8,63 @@ type BaseQueryFunction = BaseQueryFn<{
     params?: AxiosRequestConfig['params'];
     headers?: RequestConfig;
 }, unknown, unknown>;
-export declare const sdkBaseQuery: ({ baseUrl }?: {
+/**
+ * Base query function for RTK Query integration.
+ * Provides automatic error handling, authentication, and token refresh capabilities.
+ * Use this as the baseQuery for RTK Query API slices.
+ * @param config - Configuration options
+ * @param config.baseUrl - Base URL for API requests
+ * @param config.authorization - Authorization token applied to every request;
+ *   overrides the session-stored token. Per-endpoint headers still take precedence.
+ * @returns RTK Query base query function
+ * @example
+ * ```typescript
+ * import { createApi } from '@reduxjs/toolkit/query/react';
+ *
+ * const api = createApi({
+ *   reducerPath: 'api',
+ *   baseQuery: sdkBaseQuery({ baseUrl: 'https://api.example.com' }),
+ *   endpoints: (builder) => ({
+ *     getUser: builder.query({
+ *       query: (id) => ({ url: `/users/${id}`, method: 'GET' })
+ *     })
+ *   })
+ * });
+ * ```
+ * @example Passing a custom authorization token at the slice level:
+ * ```typescript
+ * const api = createApi({
+ *   reducerPath: 'api',
+ *   baseQuery: sdkBaseQuery({
+ *     baseUrl: 'https://api.example.com',
+ *     authorization: 'Bearer my-custom-token',
+ *   }),
+ *   endpoints: (builder) => ({
+ *     getUser: builder.query({
+ *       query: (id) => ({ url: `/users/${id}`, method: 'GET' })
+ *     })
+ *   })
+ * });
+ * ```
+ * @example Overriding the token for a specific endpoint via headers:
+ * ```typescript
+ * const api = createApi({
+ *   reducerPath: 'api',
+ *   baseQuery: sdkBaseQuery({ baseUrl: 'https://api.example.com' }),
+ *   endpoints: (builder) => ({
+ *     getUser: builder.query({
+ *       query: (id) => ({
+ *         url: `/users/${id}`,
+ *         method: 'GET',
+ *         headers: { Authorization: 'Bearer per-endpoint-token' },
+ *       })
+ *     })
+ *   })
+ * });
+ * ```
+ */
+export declare const sdkBaseQuery: ({ baseUrl, authorization, }?: {
     baseUrl?: string;
+    authorization?: string;
 }) => BaseQueryFunction;
 export {};

package/dist/types/lib/communication/http-client/index.d.ts

@@ -1,15 +1,50 @@
 import { AxiosInstance, RawAxiosRequestHeaders, HeadersDefaults } from 'axios';
+import { getAuthorizationHeader } from '../../utils/auth/helper.js';
 type AxiosRequestHeaders = RawAxiosRequestHeaders | Partial<HeadersDefaults>;
 export type RequestConfig = {
     Authorization?: string;
 } & AxiosRequestHeaders;
-export declare const getHTTPClient: ({ baseURL, headers, }?: {
+export { getAuthorizationHeader };
+/**
+ * Creates a basic HTTP client instance using Axios.
+ * The client includes request/response interceptors and automatic retry logic.
+ * @param config - Configuration options
+ * @param config.baseURL - Base URL for API requests (defaults to app config value)
+ * @param config.headers - Custom headers to include in requests
+ * @param config.sendLogRocketSessionHeader - Include LogRocket session URL in headers
+ * @returns Configured Axios instance
+ * @example
+ * ```typescript
+ * const client = getHTTPClient({
+ *   baseURL: 'https://api.example.com',
+ *   headers: { 'X-Custom-Header': 'value' }
+ * });
+ * const response = await client.get('/endpoint');
+ * ```
+ */
+export declare const getHTTPClient: ({ baseURL, headers, sendLogRocketSessionHeader, }?: {
     baseURL?: string;
     headers?: RequestConfig;
+    sendLogRocketSessionHeader?: boolean;
 }) => AxiosInstance;
-export declare const getAuthHTTPClient: ({ baseURL, headers, ...rest }?: {
+/**
+ * Creates an authenticated HTTP client instance with authorization headers.
+ * Automatically includes the current user's authorization token in all requests.
+ * @param config - Configuration options
+ * @param config.baseURL - Base URL for API requests (defaults to app config value)
+ * @param config.headers - Custom headers to include in requests
+ * @param config.sendLogRocketSessionHeader - Include LogRocket session URL in headers
+ * @param config.rest
+ * @returns Configured Axios instance with auth headers
+ * @example
+ * ```typescript
+ * const client = getAuthHTTPClient();
+ * const response = await client.get('/secure/endpoint');
+ * ```
+ */
+export declare const getAuthHTTPClient: ({ baseURL, headers, sendLogRocketSessionHeader, ...rest }?: {
     baseURL?: string;
     headers?: RequestConfig;
+    sendLogRocketSessionHeader?: boolean;
     rest?: any[];
 }) => AxiosInstance;
-export {};

package/dist/types/lib/communication/http-client/response-interceptor.d.ts

@@ -2,6 +2,20 @@ import { AxiosError, AxiosResponse } from 'axios';
 type FailureCallback = {
     (error: AxiosError): Promise<string>;
 };
+/**
+ * Registers a callback to handle authorization failures (401 errors).
+ * The callback should refresh the authentication token and return the new authorization header.
+ * The SDK will automatically retry the failed request with the new token.
+ * @param callback - Async function that refreshes token and returns new authorization header
+ * @example
+ * ```typescript
+ * onAuthorizationFailure(async (error) => {
+ *   const newToken = await refreshAuthToken();
+ *   sessionStorage.setItem('Authorization', newToken);
+ *   return newToken;
+ * });
+ * ```
+ */
 export declare const onAuthorizationFailure: (callback: FailureCallback) => void;
 export declare const handleSuccess: (response: AxiosResponse) => AxiosResponse;
 export declare const handleFailure: (error: AxiosError) => Promise<unknown>;

package/dist/types/lib/communication/http-client/tests/baseQuery.test.d.ts

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

package/dist/types/lib/data/auth/actions.d.ts

@@ -8,6 +8,7 @@ export interface LoginParms {
     clientId: string;
     responseType: string;
     scope: string;
+    isConsumerUser: boolean;
 }
 export interface LogoutParams {
     redirectUri: string;
@@ -15,9 +16,9 @@ export interface LogoutParams {
     responseType: string;
     scope: string;
     code: string;
-    customLogoutUrl: string;
+    customLogoutUrl?: string;
 }
 export declare const auth: {
-    login: ({ code, redirectUri, clientId, responseType, scope, }: LoginParms) => PayloadAction<LoginParms>;
+    login: ({ code, redirectUri, clientId, responseType, scope, isConsumerUser, }: LoginParms) => PayloadAction<LoginParms>;
     logout: ({ clientId, redirectUri, responseType, scope, code, customLogoutUrl, }: LogoutParams) => PayloadAction<LogoutParams>;
 };

package/dist/types/lib/data/breakpoint/index.d.ts

@@ -5,7 +5,8 @@ export declare const breakpoint: {
 export declare enum Breakpoints {
     LARGE = "large",
     MEDIUM = "medium",
-    SMALL = "small"
+    SMALL = "small",
+    XSMALL = "xsmall"
 }
 export interface BreakpointState {
     value: Breakpoints;

package/dist/types/lib/data/listenerMiddleware.d.ts

@@ -2,7 +2,36 @@ import { TypedAddListener, TypedRemoveListener, TypedStartListening } from '@red
 import type { RootState, AppDispatch } from './types.js';
 export declare const listenerMiddleware: import("@reduxjs/toolkit").ListenerMiddlewareInstance<unknown, import("@reduxjs/toolkit").ThunkDispatch<unknown, unknown, import("redux").AnyAction>, unknown>;
 export type AppStartListening = TypedStartListening<RootState, AppDispatch>;
+/**
+ * Starts a side effect listener.
+ * Used to listen for specific actions and execute side effects.
+ * @example
+ * ```typescript
+ * startSideEffect({
+ *   actionCreator: userActions.loginSuccess,
+ *   effect: async (action, listenerApi) => {
+ *     console.log('User logged in:', action.payload);
+ *   }
+ * });
+ * ```
+ */
 export declare const startSideEffect: AppStartListening;
+/**
+ * Creates a new side effect listener.
+ * Alternative API for adding listeners.
+ */
 export declare const createSideEffect: TypedAddListener<RootState, AppDispatch>;
+/**
+ * Removes a side effect listener.
+ * @example
+ * ```typescript
+ * const unsubscribe = startSideEffect({...});
+ * removeSideEffect(unsubscribe);
+ * ```
+ */
 export declare const removeSideEffect: TypedRemoveListener<RootState, AppDispatch>;
+/**
+ * Clears all registered side effect listeners.
+ * Useful for cleanup or resetting the app state.
+ */
 export declare const clearSideEffects: () => void;

package/dist/types/lib/data/store.d.ts

@@ -15,10 +15,34 @@ declare let rootReducer: import("redux").Reducer<import("redux").CombinedState<{
 }>;
 export type RootState = ReturnType<typeof rootReducer>;
 export declare const setStore: <T>(store: T) => void;
+/**
+ * Gets the global Redux store instance.
+ * @returns The configured Redux store
+ * @example
+ * ```typescript
+ * const store = getStore();
+ * store.dispatch(someAction());
+ * ```
+ */
 export declare const getStore: () => unknown;
 type MiddlewareConfig = {
     thunk?: boolean;
 };
+/**
+ * Creates and configures the Redux store with SDK middleware and enhancers.
+ * Includes saga middleware, listener middleware, RTK Query support, and hot reloading.
+ * @param initialState - Initial Redux state (defaults to empty object)
+ * @param history - History instance for routing integration
+ * @param middlewareConfig - Middleware configuration options
+ * @param injectedReducers - Pre-injected reducers
+ * @returns Configured Redux store
+ * @example
+ * ```typescript
+ * import { createAppStore, history } from '@elliemae/pui-app-sdk';
+ *
+ * const store = createAppStore({}, history);
+ * ```
+ */
 export declare const createAppStore: (initialState: RootState | undefined, history: History, middlewareConfig?: MiddlewareConfig, injectedReducers?: InjectedReducers) => import("@reduxjs/toolkit/dist/configureStore.js").ToolkitStore<import("redux").EmptyObject & {
     waitMessage: import("./wait-message/reducer.js").WaitMessageState;
     error: import("./error/index.js").ErrorState;

package/dist/types/lib/data/useAppDispatch.d.ts

@@ -1,2 +1,19 @@
 import { AppDispatch } from './types.js';
+/**
+ * React hook to get the typed dispatch function.
+ * Provides type-safe dispatching of Redux actions.
+ * @returns Typed Redux dispatch function
+ * @example
+ * ```typescript
+ * function MyComponent() {
+ *   const dispatch = useAppDispatch();
+ *
+ *   const handleClick = () => {
+ *     dispatch(myAction());
+ *   };
+ *
+ *   return <button onClick={handleClick}>Click me</button>;
+ * }
+ * ```
+ */
 export declare const useAppDispatch: () => AppDispatch;

package/dist/types/lib/data/useAppSelector.d.ts

@@ -1,3 +1,16 @@
 import { TypedUseSelectorHook } from 'react-redux';
 import { RootState } from './store.js';
+/**
+ * React hook to select data from Redux store with type safety.
+ * Automatically typed to the app's RootState.
+ * @example
+ * ```typescript
+ * function UserProfile() {
+ *   const user = useAppSelector(state => state.user.profile);
+ *   const isLoading = useAppSelector(state => state.user.loading);
+ *
+ *   return <div>{user?.name}</div>;
+ * }
+ * ```
+ */
 export declare const useAppSelector: TypedUseSelectorHook<RootState>;

package/dist/types/lib/data/useInjectQuery.d.ts

@@ -1,5 +1,34 @@
 import { Reducer, AnyAction } from 'redux';
 import { QueryMiddleware, QueryReducerPath } from './queryMiddleware.js';
+/**
+ * React hook to dynamically inject RTK Query API slice into the Redux store.
+ * Registers the reducer and middleware for the API slice at runtime.
+ * @param config - Query injection configuration
+ * @param config.reducerPath - Path where the reducer will be mounted in the store
+ * @param config.reducer - The RTK Query reducer
+ * @param config.middleware - The RTK Query middleware
+ * @example
+ * ```typescript
+ * import { createApi } from '@reduxjs/toolkit/query/react';
+ * import { useInjectQuery } from '@elliemae/pui-app-sdk';
+ *
+ * const usersApi = createApi({
+ *   reducerPath: 'usersApi',
+ *   baseQuery: sdkBaseQuery(),
+ *   endpoints: (builder) => ({...})
+ * });
+ *
+ * function MyComponent() {
+ *   useInjectQuery({
+ *     reducerPath: usersApi.reducerPath,
+ *     reducer: usersApi.reducer,
+ *     middleware: usersApi.middleware
+ *   });
+ *
+ *   return <div>...</div>;
+ * }
+ * ```
+ */
 export declare const useInjectQuery: ({ reducerPath, reducer, middleware, }: {
     reducerPath: QueryReducerPath;
     reducer: Reducer<any, AnyAction>;

package/dist/types/lib/index.d.ts

@@ -29,10 +29,12 @@ export { SessionTimeout } from './view/session-timeout/index.js';
 export { subscribeToSessionExpiryWarning, subscribeToSessionExpiry, subscribeToResetSession, resetUserIdleTime, trackActivity, } from './utils/session.js';
 export { waitMessage as waitMessageAction } from './data/wait-message/actions.js';
 export { initServiceWorker } from './utils/service-worker.js';
-export { CMicroAppGuest } from './utils/micro-frontend/guest.js';
+export { CMicroAppGuest, CMicroAppGuest as CMicroApp, } from './utils/micro-frontend/guest.js';
 export { CMicroAppHost } from './utils/micro-frontend/host.js';
+export { buildModuleParams, createGuestModule, GuestModule, } from './utils/micro-frontend/module-so.js';
+export type { HostProvidedParams, ModuleOverrides, } from './utils/micro-frontend/module-so.js';
 export { enableReactAppForHostIntegration } from './utils/app-host-integration/react.js';
-export { getAppConfigValue, setAppConfigValue, setAppConfig, } from './utils/app-config/config.js';
+export { getAppConfigValue, setAppConfigValue, setAppConfig, getAppConfig, } from './utils/app-config/config.js';
 export { getMicroFrontEndAppConfig, getLogger, } from './utils/micro-frontend/index.js';
 export { loadAppConfig } from './utils/app-config/index.js';
 export { AppRoot } from './view/app-root/index.js';
@@ -81,19 +83,18 @@ export { actions as ariaLive } from './data/live-message/index.js';
 export { actions as error } from './data/error/index.js';
 export { actions as logout } from './data/logout/actions.js';
 export { MicroApp } from './view/micro-app/index.js';
+export { GuestMicroApp } from './view/guest-microapp.js';
 export { MicroIFrameApp } from './view/micro-iframe-app/index.js';
 export { getNavigationLinks } from './view/micro-app/utils.js';
 export { getStore } from './data/store.js';
 export { RegisterService } from './utils/guest-with-service.js';
-export { setAppDynamicsUserData } from './analytics/appdynamics.js';
 export { sendBAEvent } from './analytics/index.js';
-export { updateBAEventParameters } from './utils/micro-frontend/scripting-objects/web-analytics.js';
-export { Analytics } from './utils/micro-frontend/scripting-objects/analytics.js';
+export { Analytics, updateBAEventParameters } from '@elliemae/pui-analytics-so';
 export { redactPii } from './utils/redact-pii.js';
 export type { EMUI } from './utils/window.js';
 export type { Await } from './utils/await.js';
 export type { RootState, AppStore, AppDispatch } from './data/types.js';
 export type { AppConfig } from './utils/app-config/config.js';
-export type { OnInitCallback, OnMountCallback, OnUnMountCallback, } from './utils/micro-frontend/guest.js';
+export type { GuestProps, OnInitCallback, OnMountCallback, OnUnMountCallback, } from './utils/micro-frontend/guest.js';
 export type { OnInitCallback as OnHostInitCallback } from './utils/micro-frontend/host.js';
 export type { SelectStateFieldFunction } from './utils/custom-hooks/use-state-selector.js';

package/dist/types/lib/utils/app-config/config.d.ts

@@ -14,12 +14,63 @@ export interface AppConfig {
     sessionTimeoutWarnInterval?: string;
     sessionTimeoutInterval?: string;
     serviceEndpoints: ServiceEndpoints;
+    /**
+     * Whether to use the parent history for navigation.
+     * If true, the app will use the history from the parent window.
+     * If false, it will use its own history.
+     * Defaults to true.
+     */
+    useParentHistory?: boolean;
     env: {
         [key: string]: Env;
     };
 }
+/**
+ * Sets the entire application configuration.
+ * Replaces the current configuration with the provided config object.
+ * @param config - The complete application configuration
+ * @example
+ * ```typescript
+ * setAppConfig({
+ *   appId: 'my-app',
+ *   activeEnv: 'production',
+ *   serviceEndpoints: {
+ *     api: 'https://api.example.com',
+ *     idp: 'https://auth.example.com'
+ *   },
+ *   env: {...}
+ * });
+ * ```
+ */
 export declare const setAppConfig: (config: AppConfig) => void;
+/**
+ * Gets a value from the application configuration using dot notation.
+ * Returns a deep clone to prevent accidental mutations.
+ * @template Type - Expected return type
+ * @param key - Dot-notation path to the config value (e.g., 'serviceEndpoints.api')
+ * @param defaultValue - Value to return if key doesn't exist (default: null)
+ * @returns The configuration value or default
+ * @example
+ * ```typescript
+ * const apiUrl = getAppConfigValue<string>('serviceEndpoints.api', 'https://default.com');
+ * const timeout = getAppConfigValue<number>('requestTimeout', 30000);
+ * ```
+ */
 export declare const getAppConfigValue: <Type>(key?: string, defaultValue?: unknown) => Type;
+/**
+ * Sets a value in the application configuration using dot notation.
+ * Creates nested objects if they don't exist.
+ * @template Type - Type of the value being set
+ * @param key - Dot-notation path to set (e.g., 'serviceEndpoints.api')
+ * @param value - Value to set at the specified path
+ * @returns The updated configuration object
+ * @example
+ * ```typescript
+ * setAppConfigValue('serviceEndpoints.api', 'https://new-api.com');
+ * setAppConfigValue('customSetting.enabled', true);
+ * ```
+ */
 export declare const setAppConfigValue: <Type>(key: string, value: Type) => AppConfig;
+export declare const getAppConfig: () => AppConfig;
 export declare const hasItem: (key?: string) => boolean;
 export {};

package/dist/types/lib/utils/app-config/index.d.ts

@@ -1,2 +1,20 @@
-export { getAppConfigValue } from './config.js';
+export { getAppConfigValue, getAppConfig } from './config.js';
+/**
+ * Loads the application configuration from a JSON file.
+ * Attempts to fetch from versioned path first, then falls back to unversioned path.
+ * Merges environment-specific configuration with base configuration.
+ * @param configPath - Path to the directory containing app.config.json (defaults to asset path)
+ * @throws Error if config file is not found or contains invalid JSON
+ * @example
+ * ```typescript
+ * // Load from default location
+ * await loadAppConfig();
+ *
+ * // Load from custom path
+ * await loadAppConfig('/custom/path');
+ *
+ * // After loading, access config values
+ * const apiUrl = getAppConfigValue('serviceEndpoints.api');
+ * ```
+ */
 export declare const loadAppConfig: (configPath?: string) => Promise<void>;

package/dist/types/lib/utils/auth/helper.d.ts

@@ -1,2 +1,19 @@
+/**
+ * Gets the current authorization header value from session storage.
+ * @returns The authorization header string (e.g., 'Bearer token...') or empty string if not found
+ * @example
+ * ```typescript
+ * const authHeader = getAuthorizationHeader();
+ * // 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
+ * ```
+ */
 export declare const getAuthorizationHeader: () => string;
+/**
+ * Sets the authorization header value in session storage.
+ * @param token - The authorization token to store (e.g., 'Bearer token...')
+ * @example
+ * ```typescript
+ * setAuthorizationHeader('Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...');
+ * ```
+ */
 export declare const setAuthorizationHeader: (token: string) => void;