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

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

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

@@ -1,29 +1,149 @@
 import type { EndSessionFn } from './types.js';
+/**
+ * Checks if the user is currently authorized/authenticated.
+ * @returns `true` if user has a valid authorization header, `false` otherwise
+ * @example
+ * ```typescript
+ * if (isUserAuthorized()) {
+ *   // User is logged in
+ * }
+ * ```
+ */
 export declare const isUserAuthorized: () => boolean;
 export declare const getIDPInfoFromUrl: () => {
     code: string;
     idpErrorCode: string;
     redirectUri: string;
 };
-export declare const navigateToLoginPage: ({ clientId, redirectUri, idpErrorCode, scope, responseType, }: {
+/**
+ * Navigates the user to the login page of IDP with the specified
+ * authentication parameters.
+ *
+ * Constructs the authorization URL using the provided options and
+ * redirects the browser to initiate the login flow.
+ * @param options - An object containing authentication parameters:
+ * @param options.clientId - The client identifier for the application.
+ * @param options.redirectUri - The URI to redirect to after authentication.
+ * @param options.idpErrorCode - Optional error code to pass to the IDP.
+ * @param options.scope - The scope of the authentication request.
+ * @param options.responseType - Optional response type for the
+ * authentication request.
+ * @param options.instanceId - Optional instance identifier.
+ * @param options.siteId - Optional site identifier.
+ * @param options.userId - Optional user identifier.
+ * @param options.disableRememberMe - Optional flag to disable
+ * "Remember Me" functionality.
+ * @param options.useCompactIdpPage - Optional flag. Determines whether to use a
+ * compact or full IDP page.
+ * @param options.isSSO - Optional flag. Determines whether to use
+ * SSO or not
+ */
+export declare const navigateToLoginPage: ({ clientId, redirectUri, idpErrorCode, scope, responseType, instanceId, siteId, userId, disableRememberMe, useCompactIdpPage, isSSO, }: {
     clientId: string;
     redirectUri: string;
     idpErrorCode: string;
     scope: string;
-    responseType: string;
+    responseType?: string;
+    instanceId?: number;
+    siteId?: number;
+    userId?: string;
+    disableRememberMe?: boolean;
+    useCompactIdpPage?: boolean;
+    isSSO?: boolean;
 }) => void;
+/**
+ * Ends the current user session and redirects to logout page.
+ * Revokes tokens and clears session storage.
+ * @param params - Session end parameters
+ * @param params.clientId - OAuth client ID
+ * @param params.redirectUri - URI to redirect after logout
+ * @param params.responseType - OAuth response type
+ * @param params.scope - OAuth scopes
+ * @param params.code - Optional error code
+ * @param params.customLogoutUrl - Optional custom logout URL to redirect to instead of IDP
+ * @param params.skipRevoke - Skip token revocation if true
+ * @example
+ * ```typescript
+ * await endSession({
+ *   clientId: 'my-app',
+ *   redirectUri: window.location.origin,
+ *   scope: 'openid'
+ * });
+ * ```
+ */
 export declare const endSession: EndSessionFn;
-export declare const authorize: ({ code, redirectUri, clientId, scope, responseType, }: {
+/**
+ * Handles the OAuth authorization callback after redirect from IDP.
+ * Exchanges authorization code for access token and initializes user session.
+ * @param params - Authorization parameters
+ * @param params.code - Authorization code from IDP
+ * @param params.redirectUri - Redirect URI used in OAuth flow
+ * @param params.clientId - OAuth client ID
+ * @param params.scope - OAuth scopes
+ * @param params.responseType - OAuth response type
+ * @param params.isConsumerUser - Whether user is a consumer user
+ * @example
+ * ```typescript
+ * await authorize({
+ *   clientId: 'my-app',
+ *   code: 'auth-code-from-url',
+ *   redirectUri: window.location.origin,
+ *   scope: 'openid',
+ *   responseType: 'code',
+ *   isConsumerUser: false
+ * });
+ * ```
+ */
+export declare const authorize: ({ code, redirectUri, clientId, scope, responseType, isConsumerUser, }: {
     code: string;
     redirectUri: string;
     clientId: string;
     scope: string;
     responseType: string;
+    isConsumerUser: boolean;
 }) => Promise<void>;
-export declare const login: ({ clientId, scope, responseType, }: {
+/**
+ * Initiates the login flow using OAuth/OIDC authorization code flow.
+ * If authorization code is present in URL, completes the authorization.
+ * Otherwise, redirects to the identity provider's login page.
+ * @param params - Login parameters
+ * @param params.clientId - OAuth client ID
+ * @param params.scope - OAuth scopes (e.g., 'openid profile email')
+ * @param params.responseType - OAuth response type (typically 'code')
+ * @param params.isConsumerUser - Whether user is a consumer user
+ * @param params.instanceId - (Optional) The instance identifier.
+ * @param params.siteId - (Optional) The site identifier.
+ * @param params.userId - (Optional) The user identifier.
+ * @param params.disableRememberMe - (Optional) Whether to disable the
+ * "Remember Me" option.
+ * @param params.useCompactIdpPage - (Optional). Determines whether to use a compact or
+ * full IDP page.
+ * @param params.isSSO - (Optional). Determines whether to use SSO or not.
+ * @returns Promise with authorization status
+ * @example
+ * ```typescript
+ * const result = await login({
+ *   clientId: 'my-app',
+ *   scope: 'openid profile',
+ *   responseType: 'code',
+ *   isConsumerUser: false
+ * });
+ * if (result.authorized) {
+ *   // User is now logged in
+ * }
+ * ```
+ */
+export declare const login: ({ clientId, scope, responseType, isConsumerUser, instanceId, siteId, userId, disableRememberMe, useCompactIdpPage, isSSO, }: {
     clientId: string;
     scope: string;
     responseType: string;
+    isConsumerUser: boolean;
+    instanceId?: number;
+    siteId?: number;
+    userId?: string;
+    disableRememberMe?: boolean;
+    useCompactIdpPage?: boolean;
+    isSSO?: boolean;
 }) => Promise<{
     authorized: boolean;
 }>;

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

@@ -1,5 +1,26 @@
 import { LoginParams } from './types';
+/**
+ * Sets login parameters for the authentication flow.
+ * Stores parameters in the global window object for use across the application.
+ * @param params - Login parameters
+ * @param params.clientId - OAuth client ID
+ * @param params.scope - OAuth scopes
+ * @param params.redirectUri - Optional redirect URI (defaults to current URL)
+ * @example
+ * ```typescript
+ * setLoginParams({
+ *   clientId: 'my-app',
+ *   scope: 'openid profile email'
+ * });
+ * ```
+ */
 export declare const setLoginParams: (params: Omit<LoginParams, "redirectUri"> & {
     redirectUri?: string;
 }) => void;
+/**
+ * Gets the stored login parameters.
+ * If not set, attempts to retrieve from session storage.
+ * @returns The login parameters object
+ * @internal
+ */
 export declare const getLoginParams: () => LoginParams;

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

@@ -1,14 +1,15 @@
 export type EndSessionFn = (params: {
     clientId: string;
-    redirectUri: string;
-    responseType: string;
+    redirectUri?: string;
+    responseType?: string;
     scope: string;
     code?: string;
+    customLogoutUrl?: string;
     skipRevoke?: boolean;
 }) => Promise<void>;
 export type LoginParams = {
     clientId: string;
     scope: string;
-    responseType: string;
-    redirectUri: string;
+    responseType?: string;
+    redirectUri?: string;
 };

package/dist/types/lib/utils/constants.d.ts

@@ -13,3 +13,4 @@ export declare const Themes: {
 };
 export declare const HOST_WINDOW_RESIZED = "HOST_WINDOW_RESIZED";
 export declare const HOST_WINDOW_BREAKPOINT_CHANGED = "HOST_WINDOW_BREAKPOINT_CHANGED";
+export declare const SESSION_RENEWAL_INTERVAL = 60000;

package/dist/types/lib/utils/custom-hooks/use-state-selector.d.ts

@@ -16,7 +16,7 @@ export interface UseStateSelectorOptions<Selected = unknown> {
  * export selectStateFieldFunc = getSelectField(name);
  * ```
  * @param {string | Array<string>} fieldName the state's field you want to acccess, this accepts nested objects access, like so 'rootObj.childObj.field'
- * @param {useStateSelectorOptions} opts options { defaultValue, equalityFn }
+ * @param {useStateSelectorOptions} opts options (defaultValue, equalityFn)
  * @returns
  */
 export declare function useStateSelector<TState = unknown, Selected = unknown>(selectStateFieldFunc: SelectStateFieldFunction<TState, Selected>, fieldName?: string | Array<string>, { defaultValue, equalityFn, }?: UseStateSelectorOptions<Selected>): Selected;
@@ -34,7 +34,7 @@ export declare function useStateSelector<TState = unknown, Selected = unknown>(s
  * export selectStateFieldFunc = getSelectField(name);
  * ```
  * @param {string | Array<string>} fieldName the state's field you want to acccess, this accepts nested objects access, like so 'rootObj.childObj.field'
- * @param {useStateSelectorOptions} opts options { defaultValue, equalityFn = shallowEqual }
+ * @param {useStateSelectorOptions} opts options (defaultValue, equalityFn = shallowEqual)
  * @returns
  */
 export declare function useStateSelectorShallow<TState = unknown, Selected = unknown>(selectStateFieldFunc: SelectStateFieldFunction<TState, Selected>, fieldName?: string | Array<string>, { defaultValue, equalityFn, }?: UseStateSelectorOptions<Selected>): Selected;