@zango-core/appbuilder 1.0.0-rc.1

package/dist/types/framework/components/SmartLink.d.ts

@@ -0,0 +1,13 @@
+import { default as React, MouseEvent, ReactNode } from 'react';
+interface SmartLinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> {
+    to: string;
+    children: ReactNode;
+    className?: string;
+    onClick?: (e: MouseEvent<HTMLElement>) => void;
+}
+/**
+ * SmartLink component that automatically chooses between React Router Link
+ * and regular anchor tag based on the route availability
+ */
+export declare const SmartLink: React.ForwardRefExoticComponent<SmartLinkProps & React.RefAttributes<HTMLAnchorElement>>;
+export {};

package/dist/types/framework/components/layout/AppSidebar.d.ts

@@ -0,0 +1,36 @@
+import { default as React } from 'react';
+import { MenuItemConfig } from '../../../types';
+/** Typed config for AppSidebar's `config` prop */
+interface AppSidebarConfig {
+    showLogo?: boolean;
+    showMenu?: boolean;
+    collapsible?: boolean;
+    customLogo?: React.ReactNode;
+    customMenuContent?: React.ReactNode;
+    customBottomContent?: React.ReactNode;
+    customNavbar?: React.ReactElement | null;
+    customMenu?: React.ReactNode;
+    theme?: 'light' | 'dark';
+    className?: string;
+    style?: React.CSSProperties;
+}
+interface NavbarLogoProps {
+    appLogo?: string;
+    appName?: string;
+    linkTo?: string;
+    collapsed?: boolean;
+}
+export declare const NavbarLogo: React.FC<NavbarLogoProps>;
+interface SidebarNavMenuProps {
+    menuItems?: MenuItemConfig[];
+    isDark?: boolean;
+}
+export declare const SidebarNavMenu: React.FC<SidebarNavMenuProps>;
+interface AppSidebarProps {
+    menuItems?: MenuItemConfig[];
+    appLogo?: string;
+    theme?: Record<string, unknown>;
+    config?: AppSidebarConfig;
+}
+export declare const AppSidebar: React.FC<AppSidebarProps>;
+export {};

package/dist/types/framework/components/layout/Breadcrumbs.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const Breadcrumbs: React.FC;

package/dist/types/framework/components/layout/CommandPalette.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const CommandPalette: React.FC;

package/dist/types/framework/components/layout/Layout.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const Layout: React.FC;

package/dist/types/framework/components/layout/Navbar.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Backward compatibility re-exports.
+ *
+ * The sidebar implementation has moved to AppSidebar.tsx (using shadcn/ui).
+ * This module preserves the public API so existing imports keep working:
+ *
+ *   import { Navbar, NavbarLogo, NavbarMenu } from './Navbar';
+ */
+export { AppSidebar as Navbar, NavbarLogo, SidebarNavMenu as NavbarMenu } from './AppSidebar';

package/dist/types/framework/components/layout/NavbarIcon.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { MenuItemConfig } from '../../../types';
+interface NavbarIconProps {
+    item: MenuItemConfig;
+}
+/**
+ * Renders a menu item icon. Handles SVG strings, emojis, and image URLs.
+ * Uses currentColor for SVG color inheritance — colors respond to
+ * hover/active states via CSS rather than imperative DOM manipulation.
+ */
+export declare const NavbarIcon: React.FC<NavbarIconProps>;
+export {};

package/dist/types/framework/components/layout/Topbar.d.ts

@@ -0,0 +1,50 @@
+import { default as React } from 'react';
+/** Profile info shape from AppContext */
+interface ProfileInfo {
+    name?: string;
+    profile_pic?: string;
+    current_role?: string;
+    user_role?: string;
+    [key: string]: unknown;
+}
+/** Typed config for Topbar's `config` prop */
+interface TopbarConfig {
+    showProfile?: boolean;
+    showLeftSection?: boolean;
+    showRightSection?: boolean;
+    showBreadcrumbs?: boolean;
+    customLeftContent?: React.ReactNode;
+    customRightContent?: React.ReactNode;
+    customProfileMenu?: React.ReactNode;
+    customViewProfile?: ((args: {
+        user?: ProfileInfo;
+        isOpen: boolean;
+        onClose: () => void;
+    }) => React.ReactNode) | null;
+    theme?: 'light' | 'dark';
+    profileMenuConfig?: ProfileMenuConfig;
+    className?: string;
+    style?: React.CSSProperties;
+}
+interface ProfileMenuConfig {
+    showViewProfile?: boolean;
+    showLogout?: boolean;
+    showRoleSwitch?: boolean;
+    customMenuItems?: React.ReactNode[];
+}
+interface TopbarLogoutButtonProps {
+    onLogout: () => void;
+    className?: string;
+}
+export declare const TopbarLogoutButton: React.FC<TopbarLogoutButtonProps>;
+export declare const TopbarViewProfileButton: ({ onViewProfile, className, }: {
+    onViewProfile: () => void;
+    className?: string;
+}) => React.ReactElement;
+export declare const Topbar: ({ profileInfo, theme, config, hidden, }: {
+    profileInfo?: ProfileInfo;
+    theme?: Record<string, unknown>;
+    config?: TopbarConfig;
+    hidden?: boolean;
+}) => React.ReactElement | null;
+export {};

package/dist/types/framework/components/layout/UserProfileDrawer.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+interface UserProfileDrawerProps {
+    isOpen: boolean;
+    onClose: () => void;
+}
+export declare const UserProfileDrawer: React.FC<UserProfileDrawerProps>;
+export default UserProfileDrawer;

package/dist/types/framework/components/layout/profile/PasswordCard.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { PasswordPolicy } from '../../../../types';
+/** Extended policy with UI-level flags that the profile API returns */
+interface ProfilePasswordPolicy extends PasswordPolicy {
+    allow_change?: boolean;
+}
+interface PasswordCardProps {
+    canSetPassword: boolean;
+    shouldSetPassword: boolean;
+    passwordPolicy: ProfilePasswordPolicy | null;
+    lastPasswordChange: string;
+    nextPasswordDue: string | null;
+    isMobile: boolean;
+    onServerMessage: (msg: string) => void;
+    onPasswordUpdated: () => void;
+}
+export declare const PasswordCard: React.NamedExoticComponent<PasswordCardProps>;
+export {};

package/dist/types/framework/components/layout/profile/PersonalInfoCard.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+interface PersonalInfoCardProps {
+    name: string;
+    email: string;
+    mobile: string;
+    originalName: string;
+    isMobile: boolean;
+    onNameSaved: (newName: string) => void;
+    onServerMessage: (msg: string) => void;
+}
+export declare const PersonalInfoCard: React.NamedExoticComponent<PersonalInfoCardProps>;
+export {};

package/dist/types/framework/components/layout/profile/ProfileRail.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+interface Role {
+    id: number;
+    name: string;
+    is_active: boolean;
+    is_default: boolean;
+    auth_config: {
+        redirect_url: string;
+    };
+    policies: number[];
+    policy_groups: number[];
+}
+interface ProfileRailProps {
+    name: string;
+    email: string;
+    currentRole: string;
+    roles: Role[];
+    profilePhoto: string | null;
+    isMobile: boolean;
+    onPhotoUpload: (e: React.ChangeEvent<HTMLInputElement>) => void;
+}
+export declare const ProfileRail: React.FC<ProfileRailProps>;
+export {};

package/dist/types/framework/components/layout/profile/SessionsCard.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+interface SessionsCardProps {
+    isOpen: boolean;
+    isMobile: boolean;
+    onServerMessage: (msg: string) => void;
+}
+export declare const SessionsCard: React.NamedExoticComponent<SessionsCardProps>;
+export {};

package/dist/types/framework/components/layout/profile/TokensCard.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+interface Token {
+    role: string;
+    created: string;
+    expiry?: string;
+}
+interface TokensCardProps {
+    tokens: Token[];
+}
+export declare const TokensCard: React.NamedExoticComponent<TokensCardProps>;
+export {};

package/dist/types/framework/components/layout/profile/TwoFactorCard.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+interface TwoFactorCardProps {
+    initialEnabled: boolean;
+    profileData: Record<string, unknown> | null;
+}
+export declare const TwoFactorCard: React.FC<TwoFactorCardProps>;
+export {};

package/dist/types/framework/config/defaultLayoutConfig.d.ts

@@ -0,0 +1,34 @@
+import { CustomComponentsType, LayoutConfigType, NavbarConfigType, TopbarConfigType } from '../types/layout.types';
+/**
+ * Default Layout Configuration
+ *
+ * Provides default values for all layout configuration options.
+ * These defaults ensure backward compatibility and sensible fallbacks.
+ */
+export declare const defaultLayoutConfig: LayoutConfigType;
+export declare const defaultTopbarConfig: TopbarConfigType;
+export declare const defaultNavbarConfig: NavbarConfigType;
+export declare const defaultCustomComponents: CustomComponentsType;
+/**
+ * Merge configurations with defaults
+ * Deep merges user config with defaults to ensure all properties exist
+ */
+export declare function mergeWithDefaults<T>(userConfig: T, defaultConfig: T): T;
+export declare function mergeWithDefaults(userConfig: Record<string, unknown>, defaultConfig: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Get complete configuration
+ * Merges all user configurations with defaults
+ */
+interface GetCompleteConfigParams {
+    layoutConfig?: LayoutConfigType;
+    topbarConfig?: TopbarConfigType;
+    navbarConfig?: NavbarConfigType;
+    customComponents?: CustomComponentsType;
+}
+export declare const getCompleteConfig: ({ layoutConfig, topbarConfig, navbarConfig, customComponents, }?: GetCompleteConfigParams) => {
+    layout: LayoutConfigType;
+    topbar: TopbarConfigType;
+    navbar: NavbarConfigType;
+    components: CustomComponentsType;
+};
+export {};

package/dist/types/framework/constants/routes.d.ts

@@ -0,0 +1,5 @@
+export declare const ROUTES: {
+    readonly LOGIN: "/app/login";
+    readonly APP: "/app";
+    readonly LOGOUT: "/app/logout";
+};

package/dist/types/framework/contexts/AppContext.d.ts

@@ -0,0 +1,57 @@
+import { default as React, ReactNode } from 'react';
+import { ApiConfig, AppConfig, AuthConfig, MenuItemConfig, RouteConfig, SessionSecurityConfig, ThemeConfig } from '../../types';
+import { CustomComponentsType, LayoutConfigType, NavbarConfigType, TopbarConfigType } from '../types/layout.types';
+declare global {
+    interface Window {
+        app_initializer_endpoint?: string;
+    }
+}
+interface AppData {
+    app_name?: string;
+    is_user_anonymous?: boolean;
+    routes?: RouteConfig[];
+    menu?: MenuItemConfig[];
+    profile_info?: Record<string, unknown>;
+    app_logo?: string;
+    metadata?: Record<string, unknown>;
+    theme?: ThemeConfig;
+    session_security?: SessionSecurityConfig;
+    session_security_config?: SessionSecurityConfig;
+    [key: string]: unknown;
+}
+interface AppContextType {
+    appData: AppData | null;
+    loading: boolean;
+    error: string | null;
+    config: AppConfig;
+    apiConfig: ApiConfig;
+    menu: MenuItemConfig[];
+    routes: RouteConfig[];
+    profileInfo: Record<string, unknown>;
+    appLogo: string;
+    appName: string;
+    metadata: Record<string, unknown>;
+    theme: ThemeConfig;
+    layoutConfig: LayoutConfigType;
+    topbarConfig: TopbarConfigType;
+    navbarConfig: NavbarConfigType;
+    customComponents: CustomComponentsType;
+    authConfig: AuthConfig;
+    sessionSecurity: SessionSecurityConfig | null;
+    pageTypeRegistry: Record<string, unknown> | null;
+    registryLoading: boolean;
+    registryError: string | null;
+    initializerEndpoint: string;
+}
+interface AppProviderProps {
+    children: ReactNode;
+    config?: AppConfig;
+    layoutConfig?: LayoutConfigType;
+    topbarConfig?: TopbarConfigType;
+    navbarConfig?: NavbarConfigType;
+    customComponents?: CustomComponentsType;
+    authConfig?: AuthConfig;
+}
+export declare const useAppContext: () => AppContextType;
+export declare const AppProvider: React.FC<AppProviderProps>;
+export {};

package/dist/types/framework/contexts/AuthConfigContext.d.ts

@@ -0,0 +1,22 @@
+import { default as React, ReactNode } from 'react';
+import { AuthConfig } from '../../types';
+interface AuthConfigContextType {
+    authConfig: AuthConfig;
+    getLoginConfig: () => AuthConfig['login'];
+    getRoleSelectionConfig: () => AuthConfig['roleSelection'];
+    getTwoFactorConfig: () => AuthConfig['twoFactor'];
+    getResetPasswordConfig: () => AuthConfig['resetPassword'];
+    getThemeConfig: () => AuthConfig['theme'];
+    getCardConfig: () => AuthConfig['card'];
+    getLogoConfig: () => AuthConfig['logo'];
+    getProvidersConfig: () => AuthConfig['providers'];
+    getMessagesConfig: () => AuthConfig['messages'];
+    getCustomComponents: () => AuthConfig['customComponents'];
+}
+interface AuthConfigProviderProps {
+    children: ReactNode;
+    authConfig?: AuthConfig;
+}
+export declare const useAuthConfig: () => AuthConfigContextType;
+export declare const AuthConfigProvider: React.FC<AuthConfigProviderProps>;
+export {};

package/dist/types/framework/hooks/useProfileData.d.ts

@@ -0,0 +1,73 @@
+interface ProfileData {
+    name: string;
+    email: string;
+    mobile: string;
+    profile_pic: string | null;
+    last_password_changed?: string;
+    roles: Array<{
+        id: number;
+        name: string;
+        is_active: boolean;
+        is_default: boolean;
+        auth_config: {
+            redirect_url: string;
+        };
+        policies: number[];
+        policy_groups: number[];
+    }>;
+    auth_config: {
+        login_methods: Record<string, unknown>;
+        password_policy: {
+            reset: {
+                method: string[];
+                enabled: boolean;
+                expiry_hours: number;
+            };
+            min_length: number;
+            allow_change: boolean;
+            require_numbers: boolean;
+            require_lowercase: boolean;
+            require_uppercase: boolean;
+            password_expiry_days: number;
+            require_special_chars: boolean;
+            password_history_count: number;
+        };
+        two_factor_auth: {
+            required: boolean;
+            can_enable: boolean;
+            can_disable?: boolean;
+            issue?: string;
+        };
+        redirect_url: string;
+    };
+    password_policy: {
+        reset: {
+            method: string[];
+            enabled: boolean;
+            expiry_hours: number;
+        };
+        min_length: number;
+        allow_change: boolean;
+        require_numbers: boolean;
+        require_lowercase: boolean;
+        require_uppercase: boolean;
+        password_expiry_days: number;
+        require_special_chars: boolean;
+        password_history_count: number;
+    };
+    tokens: unknown[];
+}
+interface UseProfileDataReturn {
+    profileData: ProfileData | null;
+    loading: boolean;
+    error: string | null;
+    refetch: () => void;
+    shouldSetPassword: boolean;
+}
+/**
+ * Custom hook for fetching user profile data from the API
+ * @param shouldFetch - Whether to automatically fetch data on mount
+ * @returns Profile data, loading state, error state, and refetch function
+ */
+export declare const useProfileData: (shouldFetch?: boolean) => UseProfileDataReturn;
+export {};

package/dist/types/framework/hooks/useRoutes.d.ts

@@ -0,0 +1,10 @@
+import { RouteConfig } from '../../types';
+interface UseRoutesReturn {
+    routes: RouteConfig[];
+    pageTypeRegistry: Record<string, unknown> | null;
+    registryLoading: boolean;
+    registryError: string | null;
+    isValidRoute: (path: string) => boolean;
+}
+export declare const useRoutes: () => UseRoutesReturn;
+export {};

package/dist/types/framework/hooks/useSessionSecurity.d.ts

@@ -0,0 +1,17 @@
+import { SessionSecurityConfig } from '../../types';
+interface UseSessionSecurityOptions {
+    config: SessionSecurityConfig;
+    onExpire?: () => void;
+    onWarning?: () => void;
+    onActivity?: () => void;
+}
+interface UseSessionSecurityReturn {
+    showWarning: boolean;
+    countdown: number;
+    hideWarning: () => void;
+    dismissWarning: () => void;
+    renewSession: () => void;
+    logoutNow: () => void;
+}
+export declare const useSessionSecurity: ({ config, onExpire, onWarning, onActivity, }: UseSessionSecurityOptions) => UseSessionSecurityReturn;
+export {};

package/dist/types/framework/hooks/useSmartNavigation.d.ts

@@ -0,0 +1,15 @@
+interface NavigationOptions {
+    replace?: boolean;
+    state?: unknown;
+    newTab?: boolean;
+}
+interface SmartNavigationReturn {
+    navigateTo: (path: string, options?: NavigationOptions) => void;
+    isInternalRoute: (path: string) => boolean;
+}
+/**
+ * Custom hook for smart navigation that handles both React Router routes
+ * and external navigation based on available routes from API
+ */
+export declare const useSmartNavigation: () => SmartNavigationReturn;
+export {};

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

@@ -0,0 +1,35 @@
+/**
+ * Zango CRM React App Framework
+ *
+ * Main entry point for framework exports with composable architecture
+ */
+export * from '../services/api';
+export { CachedLogo } from './components/CachedLogo';
+export { CustomPageFallback } from './components/CustomPageFallback';
+export { CustomPageLoader } from './components/CustomPageLoader';
+export { DocumentHead } from './components/DocumentHead';
+export { Layout } from './components/layout/Layout';
+export { Navbar, NavbarLogo, NavbarMenu, } from './components/layout/Navbar';
+export { Topbar, TopbarLogoutButton, TopbarViewProfileButton, } from './components/layout/Topbar';
+export { UserProfileDrawer } from './components/layout/UserProfileDrawer';
+export { SmartLink } from './components/SmartLink';
+export { defaultCustomComponents, defaultLayoutConfig, defaultNavbarConfig, defaultTopbarConfig, getCompleteConfig, mergeWithDefaults, } from './config/defaultLayoutConfig';
+export { AppProvider, useAppContext } from './contexts/AppContext';
+export { useSmartNavigation } from './hooks/useSmartNavigation';
+export { CrudPage } from './pages/CrudPage';
+export { LoginPage } from './pages/LoginPage';
+export { LogoutPage } from './pages/LogoutPage';
+export { NotFoundPage } from './pages/NotFoundPage';
+export { pageTypeRegistry } from './routing/PageTypeRegistry';
+export { PageTypeRouter } from './routing/PageTypeRouter';
+export type { AppConfigurationType, CustomComponentsType, LayoutConfigType, NavbarConfigType, TopbarConfigType, } from './types/layout.types';
+export { getApiConfig, getBaseUrl, resolveApiUrl, useApiConfig, useRouteConfig, } from './utils/apiConfig';
+export { buildApiUrl } from './utils/apiUrlUtils';
+export { generateCSSVariables, getColor } from './utils/colorUtils';
+export { deleteCookie } from './utils/cookieUtils';
+export { getCsrfToken, getCsrfTokenForRequest, setCsrfToken, validateCsrfToken, } from './utils/csrf';
+export { logoCache } from './utils/logoCache';
+export { getNextParam, getValidRedirectUrl, validateRedirectUrl, } from './utils/redirectUtils';
+export { safeNavigate, safeWindowRedirect, safeWindowReplace, } from './utils/safeRedirect';
+export { getSafeSessionStorage, removeSafeSessionStorage, sanitizeForStorage, setSafeSessionStorage, } from './utils/storageSanitizer';
+export { ZangoApp } from './ZangoApp';

package/dist/types/framework/pages/ConfigurePage.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const ConfigurePage: React.FC;

package/dist/types/framework/pages/CrudPage.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+interface CrudPageProps {
+    basePath?: string;
+}
+export declare const CrudPage: React.FC<CrudPageProps>;
+export {};

package/dist/types/framework/pages/LoginPage.d.ts

@@ -0,0 +1,5 @@
+interface LoginPageProps {
+    basePath?: string;
+}
+export declare const LoginPage: React.FC<LoginPageProps>;
+export {};

package/dist/types/framework/pages/LogoutPage.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const LogoutPage: React.FC;

package/dist/types/framework/pages/NotFoundPage.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+interface NotFoundPageProps {
+    message?: string;
+}
+export declare const NotFoundPage: React.FC<NotFoundPageProps>;
+export {};

package/dist/types/framework/pages/TrainingPage.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+interface TrainingPageProps {
+    basePath?: string;
+}
+export declare const TrainingPage: React.FC<TrainingPageProps>;
+export {};

package/dist/types/framework/routing/PageTypeRegistry.d.ts

@@ -0,0 +1,43 @@
+import { default as React } from 'react';
+interface PageComponentProps {
+    basePath?: string;
+    matchedRoutePath?: string;
+    pageType?: string;
+    apiConfig?: {
+        apiUrl?: string;
+        headers?: Record<string, string>;
+    };
+    [key: string]: unknown;
+}
+interface CustomPageHandlerParams {
+    customPages: Record<string, React.ComponentType<Record<string, unknown>>>;
+    customPagePath: string;
+    location: Location;
+    matchedRoute?: {
+        path: string | null;
+        component?: string;
+        [key: string]: unknown;
+    } | null;
+    [key: string]: unknown;
+}
+export interface PageTypeConfig {
+    component?: React.ComponentType<PageComponentProps> | null;
+    includeBasePath?: boolean;
+    standalone?: boolean;
+    propsBuilder?: (params: PageComponentProps) => Record<string, unknown>;
+    handler?: (params: CustomPageHandlerParams) => React.ReactElement;
+}
+interface PageTypeRegistry {
+    [key: string]: PageTypeConfig;
+}
+/**
+ * Page Type Registry - Centralized configuration for all page types
+ *
+ * Each page type can have:
+ * - component: The React component to render
+ * - includeBasePath: Whether to pass basePath prop (defaults to true)
+ * - propsBuilder: Function to build additional props
+ * - handler: Custom rendering function (overrides component)
+ */
+export declare const pageTypeRegistry: PageTypeRegistry;
+export {};

package/dist/types/framework/routing/PageTypeRouter.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { RouteConfig } from '../../types';
+interface PageTypeRouterProps {
+    customPages?: Record<string, React.ComponentType>;
+    forceRoute?: RouteConfig;
+}
+/**
+ * PageTypeRouter - Dynamic routing component that determines which page component to render
+ * based on the current URL and route configuration from the API
+ */
+export declare const PageTypeRouter: React.FC<PageTypeRouterProps>;
+export {};

package/dist/types/framework/routing/dynamicPageRegistry.d.ts

@@ -0,0 +1,41 @@
+import { default as React } from 'react';
+interface PageTypeConfig {
+    component?: React.ComponentType<Record<string, unknown>> | React.LazyExoticComponent<React.ComponentType<Record<string, unknown>>> | null;
+    includeBasePath?: boolean;
+    standalone?: boolean;
+    propsBuilder?: (params: Record<string, unknown>) => Record<string, unknown>;
+    handler?: (params: Record<string, unknown>) => React.ReactElement;
+}
+interface PageTypeRegistry {
+    [key: string]: PageTypeConfig;
+}
+/**
+ * Create dynamic page registry based on available packages and requested page types
+ */
+export declare const createDynamicPageRegistry: (requestedPageTypes?: string[]) => Promise<PageTypeRegistry>;
+/**
+ * Extract unique page types from route configuration
+ */
+export declare const extractPageTypesFromRoutes: (routes: Array<{
+    page_type: string;
+}>) => string[];
+/**
+ * Create registry based on API route configuration
+ */
+export declare const createRegistryFromRoutes: (routes: Array<{
+    page_type: string;
+}>) => Promise<PageTypeRegistry>;
+/**
+ * Validate that a registry has the required page type
+ */
+export declare const hasPageType: (registry: PageTypeRegistry, pageType: string) => boolean;
+/**
+ * Get registry statistics for debugging
+ */
+export declare const getRegistryStats: (registry: PageTypeRegistry) => {
+    totalPages: number;
+    dynamicPages: number;
+    staticPages: string[];
+    availablePageTypes: string[];
+};
+export {};

package/dist/types/framework/routing/getRenderComponent.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+import { PageTypeConfig } from './PageTypeRegistry';
+/**
+ * Get the appropriate component to render based on page type
+ */
+export declare const getRenderComponent: (pageType: string | null, registry: Record<string, PageTypeConfig>, context: Record<string, unknown>) => React.ReactElement;