@fluid-app/portal-sdk 0.1.11

package/dist/index.d.cts

@@ -0,0 +1,2500 @@
+import React$1, { AnchorHTMLAttributes, ComponentProps, ComponentType, ReactNode } from "react";
+import { QueryClient, UseQueryResult } from "@tanstack/react-query";
+import * as _fluid_app_portal_core_types0 from "@fluid-app/portal-core/types";
+import { AlignOptions, BackgroundType, BackgroundValue, BorderRadiusOptions, ButtonSizeOptions, ColorOptions, FontSizeOptions, GapOptions, NavigationItem, NavigationItem as NavigationItem$1, PaddingOptions, RepAppData, RepAppData as RepAppData$1, RepAppManifest, RepAppProfile, ResolvedTheme, ScreenDefinition as ScreenDefinition$1, SectionLayoutType, ShareableItem, ThemeColorInput, ThemeDefinition, ThemePayload, TypedWidgetSchema, WIDGET_TYPE_NAMES, WidgetPath, WidgetRegistry, WidgetRegistry as WidgetRegistry$1, WidgetSchema, WidgetSchema as WidgetSchema$1, WidgetType, WidgetTypeName, assertDefined, assertNever, isWidgetType, isWidgetTypeName, sectionLayoutConfig } from "@fluid-app/portal-core/types";
+import { RawApiTheme, RawApiTheme as RawApiTheme$1, buildThemeDefinition, getActiveThemeId, transformThemes } from "@fluid-app/portal-core/theme";
+import { AUTH_CONSTANTS, DEFAULT_AUTH_URL, FluidAuthConfig, FluidAuthContextValue, JWTPayload, STORAGE_KEYS, TokenValidationResult, URL_PARAMS, USER_TYPES, UserType, cleanTokenFromUrl, clearTokens, createDefaultAuthRedirect, decodeToken, extractAllTokensFromUrl, extractCompanyTokenFromUrl, extractTokenFromUrl, getStoredToken, getTokenExpiration, getTokenTimeRemaining, hasStoredToken, hasTokenInUrl, isTokenExpired, isUserType, isValidToken, storeToken, validateToken } from "@fluid-app/auth";
+import { FileUploader, FileUploader as FileUploader$1, MessagingAuthContext, MessagingAuthContext as MessagingAuthContext$1, MessagingCurrentUser, UploadCallbacks, UploadResult } from "@fluid-app/messaging-core";
+import { MessagingApiConfig } from "@fluid-app/messaging-api-client";
+import { AlertWidget, CalendarWidget, CarouselWidget, CatchUpWidget, ChartWidget, ContainerWidget, EmbedWidget, ImageWidget, LayoutWidget, ListWidget, MySiteWidget, NestedWidget, QuickShareWidget, RecentActivityWidget, SpacerWidget, TableWidget, TextWidget, ToDoWidget, VideoWidget, alertWidgetPropertySchema, calendarWidgetPropertySchema, carouselWidgetPropertySchema, catchUpWidgetPropertySchema, chartWidgetPropertySchema, containerWidgetPropertySchema, embedWidgetPropertySchema, imageWidgetPropertySchema, layoutWidgetPropertySchema, listWidgetPropertySchema, mySiteWidgetPropertySchema, nestedWidgetPropertySchema, quickShareWidgetPropertySchema, recentActivityWidgetPropertySchema, spacerWidgetPropertySchema, tableWidgetPropertySchema, textWidgetPropertySchema, toDoWidgetPropertySchema, videoWidgetPropertySchema, widgetPropertySchemas } from "@fluid-app/portal-widgets/widgets";
+import { PROPERTY_FIELD_TYPES, PropertyFieldSchema, PropertyFieldType, TabConfig, WidgetPropertySchema, gapValues, isPropertyFieldType } from "@fluid-app/portal-core/registries";
+import { createScreen, createWidgetFromShareable, createWidgetRegistry, groupChildrenByColumn } from "@fluid-app/portal-core/widget-utils";
+import { ThemeMode, ThemeModeProvider, getThemeModeAttribute, useThemeMode } from "@fluid-app/portal-core/shell/ThemeModeContext";
+
+//#region \0rolldown/runtime.js
+//#endregion
+//#region src/types/rep.d.ts
+/**
+* Rep (sales representative) user profile
+*/
+interface Rep {
+  readonly id: string;
+  email: string;
+  first_name: string;
+  last_name: string;
+  avatar_url?: string;
+  phone?: string;
+  readonly company_id: string;
+  readonly created_at: string;
+  readonly updated_at: string;
+}
+/**
+* Data for updating a rep's profile
+*/
+interface UpdateRepData {
+  first_name?: string;
+  last_name?: string;
+  avatar_url?: string;
+  phone?: string;
+}
+/**
+* Current user profile from GET /api/me endpoint.
+* Contains recipient_id needed for the messaging system.
+* Field names match the Rails API response (snake_case).
+*/
+interface UserMe {
+  readonly id: number;
+  readonly first_name: string | null;
+  readonly last_name: string | null;
+  readonly email: string;
+  readonly image_url: string | null;
+  readonly jwt: string;
+  readonly recipient_id: number | null;
+  readonly company_id?: number;
+  readonly affiliate_id: number | null;
+}
+//#endregion
+//#region src/types/page-template.d.ts
+/**
+* Category for organizing page templates in the registry
+*/
+interface PageCategory {
+  /** Unique identifier for the category */
+  readonly id: string;
+  /** Display label */
+  label: string;
+  /** Icon identifier (e.g., lucide icon name) */
+  icon?: string;
+}
+/**
+* A reusable page template that can be shared across multiple navigations
+*/
+interface PageTemplate {
+  /** Unique identifier for the template */
+  readonly id: string;
+  /** URL-friendly slug */
+  slug: string;
+  /** Display name */
+  name: string;
+  /** Description of the template's purpose */
+  description?: string;
+  /** Category ID for organization */
+  category: string;
+  /** Tags for filtering and search */
+  tags?: readonly string[];
+  /** The widget tree that defines the page content */
+  component_tree: readonly WidgetSchema[];
+  /** Semantic version of the template */
+  version: string;
+  /** Whether this is a core feature that cannot be removed */
+  isCore?: boolean;
+  /** Default prop values that can be customized */
+  defaultProps?: Readonly<Record<string, unknown>>;
+  /** Thumbnail image URL for UI display */
+  thumbnail?: string;
+}
+/**
+* Reference to a shared page template within a navigation
+*/
+interface PageReference {
+  /** ID of the page template being referenced */
+  page_template_id: string;
+  /** Screen ID to assign to this page in the navigation */
+  screen_id: number;
+  /** Optional prop overrides (only prop values, not widget structure) */
+  overrides?: readonly PageOverride[];
+}
+/**
+* Override for a specific widget's props within a page template
+*/
+interface PageOverride {
+  /** ID of the widget to override (must match WidgetSchema.id in the template) */
+  readonly widget_id: string;
+  /** Props to override (merged with original props) */
+  props: Readonly<Record<string, unknown>>;
+}
+/**
+* Built-in page category IDs
+*/
+declare const PAGE_CATEGORIES: {
+  readonly CORE: "core";
+  readonly COMMERCE: "commerce";
+  readonly COMMUNICATION: "communication";
+  readonly DATA: "data";
+  readonly CUSTOM: "custom";
+};
+type PageCategoryId = (typeof PAGE_CATEGORIES)[keyof typeof PAGE_CATEGORIES];
+//#endregion
+//#region src/types/navigation.d.ts
+/**
+* Screen definition with its component tree
+*/
+interface ScreenDefinition {
+  readonly id: number;
+  slug: string;
+  name: string;
+  component_tree: WidgetSchema[];
+}
+/**
+* Navigation configuration for the portal
+*/
+interface Navigation {
+  readonly definition_id: number;
+  readonly id: number;
+  name: string;
+  navigation_items: _fluid_app_portal_core_types0.NavigationItem[];
+  /** Local screen definitions (for backwards compatibility and custom screens) */
+  screens: ScreenDefinition[];
+  /** References to shared page templates from the registry */
+  page_refs?: PageReference[];
+}
+//#endregion
+//#region src/types/profile.d.ts
+/**
+* Portal profile containing themes and navigation configuration
+*/
+interface Profile {
+  /** Profile name */
+  name: string;
+  /** Available themes for the portal */
+  themes: ThemeDefinition[];
+  /** Navigation structure and screens */
+  navigation: Navigation;
+  /** Portal definition ID */
+  readonly definition_id: number;
+}
+//#endregion
+//#region src/types/permissions.d.ts
+/**
+* Standard permission action constants.
+* Use these constants instead of string literals for type safety.
+*
+* @example
+* ```ts
+* if (permissions[PERMISSION_ACTIONS.view]) { ... }
+* ```
+*/
+declare const PERMISSION_ACTIONS: {
+  readonly view: "view";
+  readonly create: "create";
+  readonly update: "update";
+  readonly delete: "delete";
+  readonly settings: "settings";
+  readonly add: "add";
+  readonly manage: "manage";
+  readonly send: "send";
+};
+/**
+* Union type of standard permission actions.
+* Derived from PERMISSION_ACTIONS constant to avoid duplication.
+*/
+type PermissionAction = (typeof PERMISSION_ACTIONS)[keyof typeof PERMISSION_ACTIONS];
+/**
+* Permission flags for a single resource.
+* Known actions have explicit properties; index signature allows custom actions.
+*/
+interface ResourcePermissions {
+  readonly view?: boolean;
+  readonly create?: boolean;
+  readonly update?: boolean;
+  readonly delete?: boolean;
+  readonly settings?: boolean;
+  readonly add?: boolean;
+  readonly manage?: boolean;
+  readonly send?: boolean;
+  /** Allow custom action keys beyond the standard set */
+  readonly [key: string]: boolean | undefined;
+}
+/**
+* Map of resource names to their permissions
+*/
+type Permissions = Record<string, ResourcePermissions>;
+/**
+* User's complete permission profile
+*/
+interface UserPermissions {
+  /** Resource permission mappings */
+  permissions: Permissions;
+  /** User's assigned roles */
+  roles: readonly string[];
+  /** Super admin bypass flag */
+  is_super_admin: boolean;
+}
+//#endregion
+//#region ../../platform/api-client-core/src/fetch-client.d.ts
+interface RequestOptions$1 {
+  method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+  headers?: Record<string, string>;
+  params?: Record<string, unknown>;
+  body?: unknown;
+  signal?: AbortSignal;
+}
+interface FetchClientInstance {
+  request: <TResponse = unknown>(endpoint: string, options?: RequestOptions$1) => Promise<TResponse>;
+  requestWithFormData: <TResponse = unknown>(endpoint: string, formData: FormData, options?: Omit<RequestOptions$1, "body" | "params"> & {
+    method?: "POST" | "PUT" | "PATCH";
+  }) => Promise<TResponse>;
+  get: <TResponse = unknown>(endpoint: string, params?: Record<string, unknown>, options?: Omit<RequestOptions$1, "method" | "params">) => Promise<TResponse>;
+  post: <TResponse = unknown>(endpoint: string, body?: unknown, options?: Omit<RequestOptions$1, "method" | "body">) => Promise<TResponse>;
+  put: <TResponse = unknown>(endpoint: string, body?: unknown, options?: Omit<RequestOptions$1, "method" | "body">) => Promise<TResponse>;
+  patch: <TResponse = unknown>(endpoint: string, body?: unknown, options?: Omit<RequestOptions$1, "method" | "body">) => Promise<TResponse>;
+  delete: <TResponse = unknown>(endpoint: string, options?: Omit<RequestOptions$1, "method">) => Promise<TResponse>;
+}
+type FetchClient = FetchClientInstance;
+//#endregion
+//#region ../../fluidos/api-client/src/generated/fluid_os.d.ts
+interface components {
+  schemas: {
+    ResponseMeta: {
+      /** @example 123e4567-e89b-12d3-a456-426614174000 */request_id?: string; /** @example 2021-01-01T00:00:00Z */
+      timestamp?: string;
+    }; /** @description Pagination metadata for list responses */
+    PaginationMeta: {
+      /**
+       * @description Total number of items across all pages
+       * @example 42
+       */
+      total_count?: number;
+      /**
+       * @description Total number of pages
+       * @example 5
+       */
+      total_pages?: number;
+      /**
+       * @description Current page number
+       * @example 1
+       */
+      current_page?: number;
+      /**
+       * @description Unique identifier for the request
+       * @example 123e4567-e89b-12d3-a456-426614174000
+       */
+      request_id?: string;
+      /**
+       * @description Timestamp of the response
+       * @example 2021-01-01T00:00:00Z
+       */
+      timestamp?: string;
+    } & {
+      [key: string]: unknown;
+    }; /** FluidOS::NavigationItem */
+    FluidOSNavigationItem: {
+      id: number;
+      icon?: string | null;
+      label?: string | null;
+      parent_id?: number | null;
+      position?: number | null;
+      screen_id?: number | null;
+      slug?: string | null; /** @enum {string} */
+      source: "user" | "system" | "code";
+      children: components["schemas"]["FluidOSNavigationItem"][];
+    }; /** @description Permission configuration object defining access rights. Empty arrays mean 'allow all' for that dimension. */
+    FluidOSPermissions: {
+      /** @description Array of rank IDs that can access this profile. Empty array allows all ranks. */ranks?: number[]; /** @description Array of roles that can access this profile. Empty array allows all roles. */
+      roles?: ("admin" | "rep")[]; /** @description Array of platforms that can access this profile. Empty array allows all platforms. */
+      platform?: ("mobile" | "browser")[]; /** @description Array of country IDs that can access this profile. Empty array allows all countries. */
+      countries?: number[];
+    }; /** @description Standard error response */
+    Error: {
+      /**
+       * @description Simple error message (used for 404 and other simple errors)
+       * @example Resource not found
+       * @example Unauthorized
+       */
+      error?: string;
+      /**
+       * @description Error message for validation errors
+       * @example Invalid parameters
+       */
+      error_message?: string;
+      /**
+       * @description Detailed validation errors by field
+       * @example {
+       *       "definition": {
+       *         "name": [
+       *           "must be filled"
+       *         ]
+       *       }
+       *     }
+       */
+      errors?: {
+        [key: string]: unknown;
+      };
+      meta?: components["schemas"]["ResponseMeta"];
+    } & {
+      [key: string]: unknown;
+    }; /** @description A profile optimized for rendering, with permissions stripped. Contains only the data needed to render the app. */
+    FluidOSRendererProfile: {
+      /** @description Unique identifier for the profile */id?: number; /** @description Display name of the profile */
+      name?: string; /** @description Whether this is the default profile for its platform */
+      default?: boolean; /** @description Navigation configuration for this profile */
+      navigation?: {
+        /** @description Tree structure of navigation items */navigation_tree?: components["schemas"]["FluidOSNavigationItem"][];
+      }; /** @description Array of theme IDs associated with this profile */
+      themes?: number[];
+    }; /** @description The Fluid OS manifest optimized for rendering. Contains a single matched profile based on platform, country, rank, and role parameters, along with filtered screens and themes. */
+    FluidOSRendererManifest: {
+      /** @description Name of the Fluid OS app */name?: string; /** @description ID of the Fluid OS definition */
+      definition_id?: number; /** @description Version number of the published manifest */
+      published_version?: number;
+      /**
+       * Format: date-time
+       * @description When this version was published
+       */
+      published_at?: string; /** @description Navigation configurations for the app */
+      navigations?: components["schemas"]["FluidOSNavigationBasic"][]; /** @description The best matching profile for the given parameters */
+      profile?: components["schemas"]["FluidOSRendererProfile"]; /** @description Screens associated with the matched profile's navigation */
+      screens?: components["schemas"]["FluidOSScreen"][]; /** @description Themes associated with the matched profile */
+      themes?: components["schemas"]["FluidOSTheme"][];
+    }; /** FluidOS::Navigation */
+    FluidOSNavigationBasic: {
+      id: number;
+      name?: string | null;
+      definition_id: number; /** @enum {string} */
+      platform: "web" | "mobile";
+    }; /** FluidOS::Screen */
+    FluidOSScreen: {
+      id: number;
+      name?: string | null;
+      slug?: string | null;
+      definition_id: number;
+      component_tree?: Record<string, unknown> | null;
+    }; /** FluidOS::Theme */
+    FluidOSTheme: {
+      id: number;
+      config?: Record<string, unknown> | null;
+      active?: boolean | null;
+      name?: string | null;
+      definition_id: number;
+    }; /** FluidOS::Definition */
+    FluidOSDefinition: {
+      id: number;
+      name?: string | null;
+      active?: boolean | null;
+      profiles: components["schemas"]["FluidOSProfile"][];
+      screens: components["schemas"]["FluidOSScreenBasic"][];
+      navigations: components["schemas"]["FluidOSNavigationBasic"][];
+      themes: components["schemas"]["FluidOSTheme"][];
+    }; /** FluidOS::Definition */
+    FluidOSDefinitionBasic: {
+      id: number;
+      name?: string | null;
+      active?: boolean | null;
+    };
+    FluidOSDefinitionCreate: {
+      definition: {
+        name: string;
+        active?: boolean;
+      };
+    };
+    FluidOSDefinitionUpdate: {
+      definition: {
+        name?: string;
+        active?: boolean;
+      };
+    }; /** FluidOS::Screen */
+    FluidOSScreenBasic: {
+      id: number;
+      name?: string | null;
+      slug?: string | null;
+      definition_id: number;
+    };
+    FluidOSScreenCreate: {
+      screen: {
+        name: string;
+        slug: string;
+        component_tree?: null | Record<string, unknown>;
+      };
+    };
+    FluidOSScreenUpdate: {
+      screen?: unknown;
+    }; /** FluidOS::Profile */
+    FluidOSProfile: {
+      id: number;
+      name?: string | null;
+      default?: boolean | null;
+      permissions?: components["schemas"]["FluidOSPermissions"] | null;
+      definition_id: number;
+      navigation: components["schemas"]["FluidOSNavigationWithItems"];
+      mobile_navigation: components["schemas"]["FluidOSNavigationWithItems"];
+      themes: components["schemas"]["FluidOSTheme"][];
+    }; /** FluidOS::Profile */
+    FluidOSProfileWithScreens: {
+      id: number;
+      name?: string | null;
+      default?: boolean | null;
+      permissions?: components["schemas"]["FluidOSPermissions"] | null;
+      definition_id: number;
+      navigation: components["schemas"]["FluidOSNavigationWithItems"];
+      mobile_navigation: components["schemas"]["FluidOSNavigationWithItems"];
+      themes: components["schemas"]["FluidOSTheme"][];
+      screens: {
+        [key: string]: unknown;
+      }[];
+    };
+    FluidOSProfileCreate: {
+      profile: {
+        name: string;
+        default?: boolean; /** @description Mutually exclusive with navigation_attributes */
+        navigation_id?: number; /** @description Mutually exclusive with mobile_navigation_attributes */
+        mobile_navigation_id?: number; /** @description Mutually exclusive with navigation_id */
+        navigation_attributes?: {
+          name: string;
+          navigation_items_attributes?: {
+            screen_id?: number;
+            icon?: string;
+            label?: string;
+            position?: number;
+            parent_id?: number;
+            slug?: string; /** @enum {null|string} */
+            source?: "user" | "system" | "code" | null;
+          }[];
+        }; /** @description Mutually exclusive with mobile_navigation_id */
+        mobile_navigation_attributes?: {
+          name: string;
+          navigation_items_attributes?: {
+            screen_id?: number;
+            icon?: string;
+            label?: string;
+            position?: number;
+            parent_id?: number;
+            slug?: string; /** @enum {null|string} */
+            source?: "user" | "system" | "code" | null;
+          }[];
+        };
+        theme_ids?: number[];
+        permissions?: {
+          countries?: number[];
+          ranks?: number[];
+          roles?: string[];
+          platform?: string[];
+        };
+      };
+    };
+    FluidOSProfileUpdate: {
+      profile: {
+        name?: string;
+        default?: boolean;
+        navigation_id?: number;
+        mobile_navigation_id?: number;
+        theme_ids?: number[];
+        permissions?: {
+          countries?: number[];
+          ranks?: number[];
+          roles?: string[];
+          platform?: string[];
+        };
+      };
+    };
+    FluidOSThemeCreate: {
+      theme: {
+        name: string;
+        config: Record<string, unknown>;
+        active?: boolean;
+      };
+    };
+    FluidOSThemeUpdate: {
+      theme: {
+        name?: string;
+        active?: boolean;
+        config?: Record<string, unknown>;
+      };
+    }; /** FluidOS::Navigation */
+    FluidOSNavigation: {
+      id: number;
+      name?: string | null;
+      definition_id: number; /** @enum {string} */
+      platform: "web" | "mobile";
+      screens: {
+        id: number;
+        name?: string | null;
+        slug?: string | null;
+        definition_id: number;
+        component_tree?: Record<string, unknown> | null;
+      }[];
+    }; /** FluidOS::Navigation */
+    FluidOSNavigationWithItems: {
+      id: number;
+      name?: string | null;
+      definition_id: number; /** @enum {string} */
+      platform: "web" | "mobile";
+      navigation_items: components["schemas"]["FluidOSNavigationItem"][];
+    };
+    FluidOSNavigationCreate: {
+      navigation: {
+        name: string; /** @enum {string} */
+        platform: "web" | "mobile";
+      };
+    };
+    FluidOSNavigationUpdate: {
+      navigation: {
+        name?: string; /** @enum {string} */
+        platform?: "web" | "mobile";
+      };
+    };
+    FluidOSNavigationItemCreate: {
+      navigation_item: {
+        icon?: string;
+        label: string;
+        position: number;
+        parent_id?: null | number;
+        screen_id?: null | number;
+        slug?: null | string; /** @enum {null|string} */
+        source?: "user" | "system" | "code" | null;
+      };
+    };
+    FluidOSNavigationItemUpdate: {
+      navigation_item: {
+        icon?: string;
+        label?: string;
+        position?: number;
+        parent_id?: null | number;
+        screen_id?: null | number;
+        slug?: null | string; /** @enum {null|string} */
+        source?: "user" | "system" | "code" | null;
+      };
+    }; /** FluidOS::Version */
+    FluidOSVersion: {
+      id: number;
+      active?: boolean | null;
+      manifest?: Record<string, unknown> | null; /** Format: date-time */
+      published_at?: string | null;
+      definition_id: number;
+    };
+    FluidOSVersionUpdate: {
+      version: {
+        active?: boolean;
+      };
+    };
+  };
+  responses: never;
+  parameters: never;
+  requestBodies: never;
+  headers: never;
+  pathItems: never;
+}
+//#endregion
+//#region src/client/types.d.ts
+/**
+* HTTP methods supported by the API client.
+* Use `as const` for literal type inference and type safety.
+*/
+declare const HTTP_METHODS: {
+  readonly GET: "GET";
+  readonly POST: "POST";
+  readonly PUT: "PUT";
+  readonly PATCH: "PATCH";
+  readonly DELETE: "DELETE";
+};
+/**
+* Union type of all supported HTTP methods.
+* Derived from HTTP_METHODS constant to avoid duplication.
+*/
+type HttpMethod = (typeof HTTP_METHODS)[keyof typeof HTTP_METHODS];
+/**
+* Configuration for the Fluid SDK client.
+* Use Readonly<FluidSDKConfig> when the config should not be modified after creation.
+*/
+interface FluidSDKConfig {
+  /**
+  * Base URL for API requests.
+  * Accepts either the domain root (e.g., "https://api.fluid.app") or
+  * with the /api path (e.g., "https://api.fluid.app/api").
+  * The SDK normalizes internally for each consumer.
+  */
+  readonly baseUrl: string;
+  /**
+  * Function to retrieve the authentication token
+  * Return null/undefined if no token is available
+  */
+  readonly getAuthToken?: () => string | null | Promise<string | null>;
+  /**
+  * Callback invoked when a 401 authentication error occurs
+  * Use this to trigger re-authentication flows
+  */
+  readonly onAuthError?: () => void;
+  /**
+  * Default headers to include in all requests
+  * Example: { "x-fluid-client": "portal" }
+  */
+  readonly defaultHeaders?: Readonly<Record<string, string>>;
+  /**
+  * Filestack API key for messaging file uploads.
+  * If not provided, file attachments will be disabled in the messaging composer.
+  */
+  readonly filestackApiKey?: string;
+  /**
+  * Override WebSocket URL for real-time messaging.
+  * Default: derived from baseUrl by replacing trailing /api with /cable
+  */
+  readonly websocketUrl?: string;
+}
+/**
+* Options for individual API requests.
+* Uses HttpMethod type for method to ensure type safety.
+*/
+interface RequestOptions {
+  readonly method?: HttpMethod;
+  readonly body?: unknown;
+  readonly params?: Readonly<Record<string, unknown>>;
+  readonly headers?: Readonly<Record<string, string>>;
+  readonly signal?: AbortSignal;
+}
+/**
+* Pagination parameters for list endpoints
+*/
+interface PaginationParams {
+  readonly page?: number;
+  readonly per_page?: number;
+}
+/**
+* Sort order constant - single source of truth for sort direction values.
+* Use SORT_ORDERS.asc instead of "asc" for type-safe comparisons.
+*/
+declare const SORT_ORDERS: {
+  readonly asc: "asc";
+  readonly desc: "desc";
+};
+/**
+* Union type of sort order values, derived from SORT_ORDERS constant.
+* @see deriving-typeof-for-object-keys pattern
+*/
+type SortOrder = (typeof SORT_ORDERS)[keyof typeof SORT_ORDERS];
+/**
+* Common filter parameters for list endpoints
+*/
+interface BaseListParams extends PaginationParams {
+  readonly sort_by?: string;
+  readonly sort_order?: SortOrder;
+  readonly search?: string;
+}
+//#endregion
+//#region src/transforms/screen-transforms.d.ts
+/** Raw screen from the FluidOS API */
+interface RawApiScreen {
+  id: number | string;
+  definition_id?: number | string;
+  name?: string | null;
+  slug?: string | null;
+  component_tree?: unknown;
+}
+/**
+* Normalize component_tree to always be an array.
+* The API stores component_tree as a hash (object), but the frontend expects an array.
+*/
+declare function normalizeComponentTree(componentTree: unknown): WidgetSchema$1[];
+/**
+* Convert a raw FluidOS screen to ScreenDefinition.
+* Normalizes component_tree and converts string IDs to numbers.
+*/
+declare function toScreenDefinition(screen: RawApiScreen): ScreenDefinition$1;
+//#endregion
+//#region src/transforms/navigation-transforms.d.ts
+/** Raw navigation item from the FluidOS API (derived from generated types) */
+type RawApiNavigationItem = components["schemas"]["FluidOSNavigationItem"];
+/**
+* Convert a raw FluidOS navigation item to NavigationItem.
+* Recursively transforms children and sorts by position.
+*/
+declare function toNavigationItem(item: RawApiNavigationItem): NavigationItem$1;
+//#endregion
+//#region src/transforms/index.d.ts
+/** Raw manifest shape from the `/fluid_os/definitions/active` API response */
+interface RawManifestResponse {
+  manifest: {
+    definition_id: number;
+    published_version?: number;
+    screens?: RawApiScreen[];
+    profile?: {
+      name?: string;
+      definition_id: number;
+      themes?: RawApiTheme$1[];
+      navigation?: {
+        id: number;
+        name?: string;
+        definition_id: number;
+        navigation_items?: RawApiNavigationItem[];
+      };
+      mobile_navigation?: {
+        id: number;
+        name?: string;
+        definition_id: number;
+        navigation_items?: RawApiNavigationItem[];
+      };
+    };
+  };
+}
+/**
+* Transform a raw FluidOS manifest API response into RepAppData.
+*
+* This is the top-level transform used by `FluidClient.app.get()`.
+* It handles:
+* - Theme transformation (legacy and new formats)
+* - Screen normalization (component_tree array wrapping)
+* - Navigation item transformation (recursive with position sorting)
+*/
+declare function transformManifestToRepAppData(response: RawManifestResponse): RepAppData$1;
+//#endregion
+//#region src/client/fluid-client.d.ts
+/**
+* API Error class for structured error handling
+*/
+declare class ApiError extends Error {
+  readonly status: number;
+  readonly data: unknown;
+  constructor(message: string, status: number, data?: unknown);
+  toJSON(): {
+    name: string;
+    message: string;
+    status: number;
+    data: unknown;
+  };
+}
+/**
+* Type guard for ApiError
+*/
+declare function isApiError(error: unknown): error is ApiError;
+/**
+* Discriminated union representing the result of an API call.
+* Use `isApiSuccess` and `isApiFailure` type guards to narrow.
+*/
+type ApiResult<T> = {
+  readonly success: true;
+  readonly data: T;
+} | {
+  readonly success: false;
+  readonly error: ApiError;
+};
+interface Product {
+  readonly id: number;
+  readonly title: string;
+  readonly sku?: string | null;
+  readonly price: string | number;
+  readonly description?: string | null;
+  readonly image_url?: string;
+  readonly status?: string;
+  readonly active?: boolean;
+  readonly slug?: string;
+  readonly in_stock?: boolean;
+  readonly display_price?: string;
+  readonly currency_code?: string;
+  readonly updated_at?: string;
+}
+interface ProductListParams extends BaseListParams {
+  readonly search_query?: string;
+  readonly status?: readonly ("active" | "draft" | "archived" | "all")[];
+  readonly category_id?: string;
+  readonly category_ids?: readonly number[];
+  readonly collection_id?: string;
+  readonly collection_ids?: readonly number[];
+  readonly order_by?: readonly string[];
+  readonly country_code?: readonly string[];
+  readonly published_stores?: readonly ("retail" | "rep")[];
+}
+interface ProductsResponse {
+  readonly products: readonly Product[];
+  readonly meta: {
+    readonly request_id: string;
+    readonly timestamp: string;
+    readonly pagination?: {
+      readonly current_page: number;
+      readonly per_page: number;
+      readonly total_pages: number;
+      readonly total_count: number;
+    };
+  };
+}
+interface Order {
+  readonly id: string;
+  readonly order_number: string;
+  readonly status: string;
+  readonly total: number;
+  readonly customer_id: string;
+  readonly rep_id?: string;
+  readonly created_at: string;
+  readonly updated_at: string;
+}
+interface OrderListParams extends BaseListParams {
+  readonly status?: string;
+  readonly customer_id?: string;
+  readonly date_from?: string;
+  readonly date_to?: string;
+}
+interface CreateOrderData {
+  readonly customer_id: string;
+  readonly line_items: readonly OrderLineItem[];
+  readonly notes?: string;
+}
+interface OrderLineItem {
+  readonly product_id: string;
+  readonly quantity: number;
+  readonly price?: number;
+}
+interface DashboardData {
+  readonly total_sales: number;
+  readonly total_orders: number;
+  readonly total_customers: number;
+  readonly recent_orders: readonly Order[];
+}
+interface SalesParams {
+  readonly date_from?: string;
+  readonly date_to?: string;
+  readonly group_by?: "day" | "week" | "month";
+}
+interface SalesData {
+  readonly total: number;
+  readonly data: readonly SalesDataPoint[];
+}
+interface SalesDataPoint {
+  readonly date: string;
+  readonly amount: number;
+  readonly orders: number;
+}
+/**
+* The shape returned by `createFluidClient`.
+* Generic helper methods preserve their type parameters so callers
+* can specify response types at each call site.
+*/
+interface FluidClientReturn {
+  readonly fetchClient: FetchClient;
+  readonly request: <TResponse = unknown>(endpoint: string, options?: RequestOptions) => Promise<TResponse>;
+  readonly requestNullable: <TResponse>(endpoint: string, options?: RequestOptions) => Promise<TResponse | null>;
+  readonly safeRequest: <TResponse>(endpoint: string, options?: RequestOptions) => Promise<ApiResult<TResponse>>;
+  readonly get: <TResponse = unknown, TParams extends object = Record<string, unknown>>(endpoint: string, params?: TParams, options?: Omit<RequestOptions, "method" | "params">) => Promise<TResponse>;
+  readonly post: <TResponse = unknown>(endpoint: string, body?: unknown, options?: Omit<RequestOptions, "method" | "body">) => Promise<TResponse>;
+  readonly put: <TResponse = unknown>(endpoint: string, body?: unknown, options?: Omit<RequestOptions, "method" | "body">) => Promise<TResponse>;
+  readonly patch: <TResponse = unknown>(endpoint: string, body?: unknown, options?: Omit<RequestOptions, "method" | "body">) => Promise<TResponse>;
+  readonly delete: <TResponse = unknown>(endpoint: string, options?: Omit<RequestOptions, "method">) => Promise<TResponse>;
+  readonly products: {
+    readonly list: (params?: ProductListParams) => Promise<ProductsResponse>;
+    readonly get: (id: string | number) => Promise<{
+      product: Product;
+    }>;
+    readonly search: (query: string, params?: ProductListParams) => Promise<ProductsResponse>;
+  };
+  readonly orders: {
+    readonly list: (params?: OrderListParams) => Promise<Order[]>;
+    readonly get: (id: string) => Promise<Order>;
+    readonly create: (data: CreateOrderData) => Promise<Order>;
+  };
+  readonly users: {
+    readonly me: () => Promise<UserMe>;
+  };
+  readonly reps: {
+    readonly current: () => Promise<Rep>;
+    readonly updateProfile: (data: UpdateRepData) => Promise<Rep>;
+  };
+  readonly profile: {
+    readonly get: () => Promise<Profile>;
+  };
+  readonly app: {
+    readonly getRaw: () => Promise<RawManifestResponse>;
+    readonly get: () => Promise<RepAppData$1>;
+  };
+  readonly permissions: {
+    readonly get: () => Promise<UserPermissions>;
+  };
+  readonly analytics: {
+    readonly dashboard: () => Promise<DashboardData>;
+    readonly sales: (params?: SalesParams) => Promise<SalesData>;
+  };
+}
+/**
+* Creates a configured Fluid API client instance
+*/
+declare function createFluidClient(config: FluidSDKConfig): FluidClientReturn;
+type FluidClient = ReturnType<typeof createFluidClient>;
+//#endregion
+//#region src/providers/FluidProvider.d.ts
+/**
+* Context value for FluidProvider.
+* All properties are readonly since context values should not be mutated by consumers.
+*/
+interface FluidContextValue {
+  /** Configured API client instance */
+  readonly client: FluidClient;
+  /** SDK configuration */
+  readonly config: FluidSDKConfig;
+}
+interface FluidProviderProps {
+  /** SDK configuration (baseUrl, auth, etc.) */
+  config: FluidSDKConfig;
+  /** React children */
+  children: ReactNode;
+  /** Optional custom QueryClient instance */
+  queryClient?: QueryClient;
+  /** Optional initial theme */
+  initialTheme?: ThemeDefinition;
+  /** Optional container for scoped theme application */
+  themeContainer?: HTMLElement | null;
+  /** Optional custom widget registry (defaults to all built-in widgets) */
+  widgetRegistry?: Record<string, React.ComponentType<any>>;
+  /** Dynamic variables for data source endpoint path substitution (e.g., { rep_id: "123" }) */
+  variables?: Record<string, string>;
+}
+/**
+* Main provider for the Fluid Portal SDK
+*
+* @example
+* ```tsx
+* import { FluidProvider } from "@fluid-app/portal-sdk";
+*
+* function App() {
+*   return (
+*     <FluidProvider
+*       config={{
+*         baseUrl: "https://api.fluid.app/api",
+*         getAuthToken: () => localStorage.getItem("token"),
+*       }}
+*     >
+*       <YourApp />
+*     </FluidProvider>
+*   );
+* }
+* ```
+*/
+declare function FluidProvider({
+  config,
+  children,
+  queryClient,
+  initialTheme,
+  themeContainer,
+  widgetRegistry,
+  variables
+}: FluidProviderProps): React.JSX.Element;
+/**
+* Hook to access the Fluid context
+* Must be used within a FluidProvider
+*/
+declare function useFluidContext(): FluidContextValue;
+//#endregion
+//#region src/providers/FluidThemeProvider.d.ts
+type ThemeMode$1 = "light" | "dark";
+/**
+* Context value for theme management.
+* All properties are readonly since context values should not be mutated by consumers.
+*/
+interface ThemeContextValue {
+  /** Currently active theme definition */
+  readonly currentTheme: ThemeDefinition | null;
+  /** Switch to a different theme */
+  readonly setTheme: (theme: ThemeDefinition) => void;
+  /** Switch between light and dark mode for the current theme */
+  readonly setThemeMode: (mode: ThemeMode$1) => void;
+  /** Current theme mode */
+  readonly mode: ThemeMode$1 | undefined;
+}
+interface FluidThemeProviderProps {
+  children: ReactNode;
+  /** Initial theme to apply */
+  initialTheme?: ThemeDefinition;
+  /** Container element for scoped theme application (defaults to document.documentElement) */
+  container?: HTMLElement | null;
+}
+declare function FluidThemeProvider({
+  children,
+  initialTheme,
+  container
+}: FluidThemeProviderProps): React.JSX.Element;
+/**
+* Hook to access theme context
+* Must be used within a FluidThemeProvider
+*/
+declare function useThemeContext(): ThemeContextValue;
+//#endregion
+//#region src/providers/FluidAuthProvider.d.ts
+interface FluidAuthProviderProps {
+  /** React children to wrap with auth context */
+  children: ReactNode;
+  /** Auth configuration options */
+  config?: FluidAuthConfig;
+}
+/**
+* Authentication provider for Fluid portal applications.
+*
+* On mount, this provider:
+* 1. Checks for a token in the URL (passed from parent app)
+* 2. Cleans token from URL immediately (security)
+* 3. Falls back to stored token (cookie/localStorage)
+* 4. Validates the token (checks expiration)
+* 5. Stores valid tokens for future use
+* 6. Calls onAuthFailure if no valid token found
+*
+* @example
+* ```tsx
+* import { FluidAuthProvider } from "@fluid-app/portal-sdk";
+*
+* function App() {
+*   return (
+*     <FluidAuthProvider
+*       config={{
+*         onAuthFailure: () => {
+*           window.location.href = "/login";
+*         },
+*       }}
+*     >
+*       <YourApp />
+*     </FluidAuthProvider>
+*   );
+* }
+* ```
+*/
+declare function FluidAuthProvider({
+  children,
+  config
+}: FluidAuthProviderProps): React.JSX.Element;
+/**
+* Hook to access the auth context directly.
+* Prefer using `useFluidAuth` for most use cases.
+*
+* @throws Error if used outside FluidAuthProvider
+*/
+declare function useFluidAuthContext(): FluidAuthContextValue;
+//#endregion
+//#region src/types/screen-types.d.ts
+/**
+* Screen Types - Type definitions for core feature screens
+*
+* All status and type unions are derived from constants for single source of truth.
+* Use the constants (e.g., CONVERSATION_STATUSES.active) for type-safe comparisons.
+*/
+/**
+* Conversation status constant - single source of truth.
+*/
+declare const CONVERSATION_STATUSES: {
+  readonly active: "active";
+  readonly archived: "archived";
+  readonly muted: "muted";
+};
+/**
+* Union type derived from CONVERSATION_STATUSES constant.
+*/
+type ConversationStatus = (typeof CONVERSATION_STATUSES)[keyof typeof CONVERSATION_STATUSES];
+/**
+* Message type constant - single source of truth.
+*/
+declare const MESSAGE_TYPES: {
+  readonly text: "text";
+  readonly image: "image";
+  readonly file: "file";
+  readonly system: "system";
+};
+/**
+* Union type derived from MESSAGE_TYPES constant.
+*/
+type MessageType = (typeof MESSAGE_TYPES)[keyof typeof MESSAGE_TYPES];
+interface Participant {
+  readonly id: string;
+  readonly name: string;
+  readonly email: string;
+  readonly avatarUrl?: string;
+  readonly isOnline?: boolean;
+}
+/**
+* Message attachment type - extracted for reusability and clarity.
+*/
+interface MessageAttachment {
+  readonly id: string;
+  readonly name: string;
+  readonly url: string;
+  readonly type: string;
+  readonly size?: number;
+}
+interface Message {
+  readonly id: string;
+  readonly conversationId: string;
+  readonly senderId: string;
+  readonly senderName: string;
+  readonly senderAvatarUrl?: string;
+  readonly type: MessageType;
+  readonly content: string;
+  readonly timestamp: string;
+  readonly isRead: boolean;
+  readonly attachments?: readonly MessageAttachment[];
+}
+interface Conversation {
+  readonly id: string;
+  readonly title: string;
+  readonly participants: readonly Participant[];
+  readonly lastMessage?: Message;
+  readonly unreadCount: number;
+  readonly status: ConversationStatus;
+  readonly createdAt: string;
+  readonly updatedAt: string;
+}
+/**
+* Contact status constant - single source of truth.
+*/
+declare const CONTACT_STATUSES: {
+  readonly active: "active";
+  readonly inactive: "inactive";
+  readonly lead: "lead";
+  readonly prospect: "prospect";
+};
+/**
+* Union type derived from CONTACT_STATUSES constant.
+*/
+type ContactStatus = (typeof CONTACT_STATUSES)[keyof typeof CONTACT_STATUSES];
+/**
+* Contact type constant - single source of truth.
+*/
+declare const CONTACT_TYPES: {
+  readonly individual: "individual";
+  readonly company: "company";
+};
+/**
+* Union type derived from CONTACT_TYPES constant.
+*/
+type ContactType = (typeof CONTACT_TYPES)[keyof typeof CONTACT_TYPES];
+interface ContactAddress {
+  readonly street?: string;
+  readonly city?: string;
+  readonly state?: string;
+  readonly postalCode?: string;
+  readonly country?: string;
+}
+interface Contact {
+  readonly id: string;
+  readonly firstName: string;
+  readonly lastName: string;
+  readonly email: string;
+  readonly phone?: string;
+  readonly company?: string;
+  readonly jobTitle?: string;
+  readonly avatarUrl?: string;
+  readonly status: ContactStatus;
+  readonly type: ContactType;
+  readonly address?: ContactAddress;
+  readonly tags?: readonly string[];
+  readonly notes?: string;
+  readonly createdAt: string;
+  readonly updatedAt: string;
+}
+//#endregion
+//#region src/providers/PageTemplateProvider.d.ts
+/**
+* Context value for page template resolution.
+* All properties are readonly since context values should not be mutated by consumers.
+*/
+interface PageTemplateContextValue {
+  /**
+  * Resolve a navigation's page_refs and screens into a unified screen list
+  */
+  readonly resolvePages: (navigation: Navigation) => ScreenDefinition[];
+  /**
+  * Get all available page templates
+  */
+  readonly listTemplates: () => PageTemplate[];
+  /**
+  * Get a specific template by ID
+  */
+  readonly getTemplate: (id: string) => PageTemplate | undefined;
+  /**
+  * Check if a template exists
+  */
+  readonly hasTemplate: (id: string) => boolean;
+}
+/**
+* Props for PageTemplateProvider
+*/
+interface PageTemplateProviderProps {
+  children: React$1.ReactNode;
+  /**
+  * Additional custom page templates to register.
+  * These are registered when the provider mounts and unregistered when it unmounts.
+  */
+  templates?: readonly PageTemplate[];
+}
+/**
+* Provider for page template resolution.
+*
+* This provider:
+* 1. Registers any custom templates passed via props
+* 2. Provides methods for resolving navigation pages
+* 3. Cleans up custom templates on unmount
+*
+* @example
+* ```tsx
+* // With custom templates
+* const customTemplates: PageTemplate[] = [
+*   {
+*     id: 'custom-dashboard',
+*     slug: 'dashboard',
+*     name: 'Dashboard',
+*     category: 'custom',
+*     version: '1.0.0',
+*     component_tree: [{ type: 'TextWidget', props: { text: 'Custom Dashboard' } }],
+*   },
+* ];
+*
+* <PageTemplateProvider templates={customTemplates}>
+*   <App />
+* </PageTemplateProvider>
+*
+* // Without custom templates (uses only core templates)
+* <PageTemplateProvider>
+*   <App />
+* </PageTemplateProvider>
+* ```
+*/
+declare function PageTemplateProvider({
+  children,
+  templates
+}: PageTemplateProviderProps): React$1.JSX.Element;
+/**
+* Hook to access page template functionality.
+*
+* @throws Error if used outside of PageTemplateProvider
+*
+* @example
+* ```tsx
+* function NavigationRenderer({ navigation }: { navigation: Navigation }) {
+*   const { resolvePages } = usePageTemplates();
+*   const screens = resolvePages(navigation);
+*
+*   return (
+*     <div>
+*       {screens.map((screen) => (
+*         <Screen key={screen.id} definition={screen} />
+*       ))}
+*     </div>
+*   );
+* }
+* ```
+*/
+declare function usePageTemplates(): PageTemplateContextValue;
+/**
+* Hook to resolve navigation pages directly.
+* Convenience wrapper around usePageTemplates().resolvePages.
+*
+* @param navigation - The navigation to resolve
+* @returns Array of resolved screen definitions
+*/
+declare function useResolvedPages(navigation: Navigation): ScreenDefinition[];
+//#endregion
+//#region src/hooks/use-fluid-api.d.ts
+/**
+* Hook to access the Fluid API client
+*
+* @example
+* ```tsx
+* function ProductList() {
+*   const api = useFluidApi();
+*
+*   const { data: products } = useQuery({
+*     queryKey: ["products"],
+*     queryFn: () => api.products.list(),
+*   });
+*
+*   return <ul>{products?.map(p => <li key={p.id}>{p.name}</li>)}</ul>;
+* }
+* ```
+*/
+declare function useFluidApi(): FluidClient;
+//#endregion
+//#region src/hooks/use-fluid-profile.d.ts
+/**
+* Query key for profile data
+*/
+declare const PROFILE_QUERY_KEY: readonly ["fluid", "profile"];
+/**
+* Hook to fetch the portal profile (themes, navigation, screens)
+*
+* @example
+* ```tsx
+* function Navigation() {
+*   const { data: profile, isLoading } = useFluidProfile();
+*
+*   if (isLoading) return <Spinner />;
+*
+*   return (
+*     <nav>
+*       {profile?.navigation.navigation_items.map(item => (
+*         <NavItem key={item.id} item={item} />
+*       ))}
+*     </nav>
+*   );
+* }
+* ```
+*/
+declare function useFluidProfile(): UseQueryResult<Profile>;
+//#endregion
+//#region src/hooks/use-fluid-app.d.ts
+/**
+* Query key for full app data (fluidos endpoint)
+*/
+declare const APP_DATA_QUERY_KEY: readonly ["fluid", "app"];
+/**
+* Hook to fetch the full portal app data from the fluidos API.
+*
+* Returns a `RepAppData` object containing:
+* - `screens` — all screen definitions with normalized component trees
+* - `profile.themes` — fully-transformed ThemeDefinition[] (handles legacy + new formats)
+* - `profile.activeThemeId` — the currently active theme ID
+* - `profile.navigation.navigation_items` — sorted, recursive navigation tree
+*
+* Uses IndexedDB persistence so subsequent page loads hydrate instantly
+* from cache while revalidating in the background. The raw API response
+* (plain JSON) is cached; Color objects are recreated from cache via
+* `select` on every restore — this is fast (CPU only, no network).
+*
+* @example
+* ```tsx
+* function App() {
+*   const { data: appData, isLoading } = useFluidApp();
+*
+*   if (isLoading) return <Spinner />;
+*
+*   return (
+*     <AppShell
+*       appData={appData}
+*       navigation={appData.profile.navigation.navigation_items}
+*     />
+*   );
+* }
+* ```
+*/
+declare function useFluidApp(options?: {
+  enabled?: boolean;
+}): UseQueryResult<RepAppData$1>;
+//#endregion
+//#region src/hooks/use-fluid-permissions.d.ts
+/**
+* Query key for permissions data
+*/
+declare const PERMISSIONS_QUERY_KEY: readonly ["fluid", "permissions"];
+/**
+* Result of useFluidPermissions hook
+*/
+interface UseFluidPermissionsResult {
+  /** Raw permissions query result */
+  query: UseQueryResult<UserPermissions>;
+  /** Permissions data (alias for query.data) */
+  permissions: UserPermissions | undefined;
+  /** Check if user has a specific permission */
+  can: (resource: string, action?: PermissionAction) => boolean;
+  /** Check if user is a super admin */
+  isSuperAdmin: boolean;
+}
+/**
+* Hook to fetch and check user permissions
+*
+* @example
+* ```tsx
+* function TeamSettings() {
+*   const { can, isSuperAdmin } = useFluidPermissions();
+*
+*   if (!can("team", "manage")) {
+*     return <AccessDenied />;
+*   }
+*
+*   return <TeamSettingsForm canDelete={can("team", "delete")} />;
+* }
+* ```
+*/
+declare function useFluidPermissions(): UseFluidPermissionsResult;
+//#endregion
+//#region src/hooks/use-fluid-theme.d.ts
+/**
+* Result of useFluidTheme hook
+*/
+interface UseFluidThemeResult {
+  /** Currently active theme */
+  currentTheme: ThemeDefinition | null;
+  /** Switch to a different theme */
+  setTheme: (theme: ThemeDefinition) => void;
+  /** Switch between light and dark mode */
+  setThemeMode: (mode: "light" | "dark") => void;
+  /** Current theme mode (convenience accessor) */
+  mode: "light" | "dark" | undefined;
+}
+/**
+* Hook to access and control theme settings
+*
+* @example
+* ```tsx
+* function ThemeSwitcher({ themes }: { themes: ThemeDefinition[] }) {
+*   const { currentTheme, setTheme, setThemeMode, mode } = useFluidTheme();
+*
+*   return (
+*     <div>
+*       <select
+*         value={currentTheme?.name}
+*         onChange={(e) => {
+*           const theme = themes.find(t => t.name === e.target.value);
+*           if (theme) setTheme(theme);
+*         }}
+*       >
+*         {themes.map(theme => (
+*           <option key={theme.name} value={theme.name}>
+*             {theme.name}
+*           </option>
+*         ))}
+*       </select>
+*
+*       <button onClick={() => setThemeMode(mode === "dark" ? "light" : "dark")}>
+*         Toggle {mode === "dark" ? "Light" : "Dark"} Mode
+*       </button>
+*     </div>
+*   );
+* }
+* ```
+*/
+declare function useFluidTheme(): UseFluidThemeResult;
+//#endregion
+//#region src/hooks/use-current-rep.d.ts
+/**
+* Query key for current rep data
+*/
+declare const CURRENT_REP_QUERY_KEY: readonly ["fluid", "currentRep"];
+/**
+* Hook to fetch the currently authenticated rep's profile
+*
+* @example
+* ```tsx
+* function RepHeader() {
+*   const { data: rep, isLoading } = useCurrentRep();
+*
+*   if (isLoading) return <Skeleton />;
+*
+*   return (
+*     <div>
+*       <Avatar src={rep?.avatar_url} />
+*       <span>{rep?.first_name} {rep?.last_name}</span>
+*     </div>
+*   );
+* }
+* ```
+*/
+declare function useCurrentRep(): UseQueryResult<Rep>;
+//#endregion
+//#region src/hooks/use-fluid-auth.d.ts
+/**
+* Hook to access authentication state and utilities.
+*
+* Must be used within a `FluidAuthProvider`.
+*
+* @returns Authentication context with user info, loading state, and utilities
+* @throws Error if used outside FluidAuthProvider
+*
+* @example
+* ```tsx
+* function UserProfile() {
+*   const { isAuthenticated, isLoading, user, clearAuth } = useFluidAuth();
+*
+*   if (isLoading) {
+*     return <Spinner />;
+*   }
+*
+*   if (!isAuthenticated) {
+*     return <p>Please log in</p>;
+*   }
+*
+*   return (
+*     <div>
+*       <p>Welcome, {user.full_name}!</p>
+*       <button onClick={clearAuth}>Log out</button>
+*     </div>
+*   );
+* }
+* ```
+*/
+declare function useFluidAuth(): FluidAuthContextValue;
+//#endregion
+//#region src/hooks/hook-types.d.ts
+/**
+* Hook type utilities and type predicates.
+*
+* This module provides:
+* - Generic hook result types with default type parameters
+* - Type predicates for query state narrowing
+* - Reusable patterns for type-safe property access in hooks
+*
+* Following generics best practices:
+* - generics-default-type-parameters: Default E to Error for common case
+* - generics-type-predicates: Type predicates for result state narrowing
+* - generics-constrain-type-parameters: K extends keyof T for property access
+*/
+/**
+* Base result type for query hooks with default error type.
+* Uses default type parameter for E (generics-default-type-parameters rule).
+*
+* @typeParam T - The data type
+* @typeParam E - The error type (defaults to Error)
+*
+* @example
+* // Error type defaults to Error
+* type UsersResult = QueryResult<User[]>;
+*
+* // Can override when needed
+* type CustomResult = QueryResult<User[], ApiError>;
+*/
+interface QueryResult<T, E = Error> {
+  readonly data: T;
+  readonly isLoading: boolean;
+  readonly isError: boolean;
+  readonly error?: E | undefined;
+}
+/**
+* Result type for hooks that may not have data yet.
+* Extends QueryResult with nullable data.
+*
+* @typeParam T - The data type
+* @typeParam E - The error type (defaults to Error)
+*/
+interface QueryResultNullable<T, E = Error> {
+  readonly data: T | null | undefined;
+  readonly isLoading: boolean;
+  readonly isError: boolean;
+  readonly error?: E | undefined;
+}
+/**
+* Result type for list/collection hooks with aggregates.
+*
+* @typeParam T - The item type in the array
+* @typeParam E - The error type (defaults to Error)
+*/
+interface ListQueryResult<T, E = Error> extends QueryResult<T[], E> {
+  readonly totalCount: number;
+}
+/**
+* Result type for list hooks with value aggregation (e.g., deals with total value).
+*
+* @typeParam T - The item type in the array
+* @typeParam E - The error type (defaults to Error)
+*/
+interface ValueListQueryResult<T, E = Error> extends ListQueryResult<T, E> {
+  readonly totalValue: number;
+}
+/**
+* Type predicate to check if a query result has successfully loaded data.
+* Narrows the data type from T | null | undefined to T.
+*
+* @example
+* const result = useContact(id);
+* if (hasData(result)) {
+*   // TypeScript knows result.data is Contact, not Contact | null
+*   console.log(result.data.name);
+* }
+*/
+declare function hasData<T, E = Error>(result: QueryResultNullable<T, E>): result is QueryResultNullable<T, E> & {
+  readonly data: T;
+};
+/**
+* Type predicate to check if a query result is in loading state.
+* Useful for conditional rendering.
+*
+* @example
+* if (isLoading(result)) {
+*   return <Spinner />;
+* }
+*/
+declare function isLoading<T, E = Error>(result: QueryResult<T, E> | QueryResultNullable<T, E>): boolean;
+/**
+* Type predicate to check if a query result has an error.
+* Narrows to include the error property.
+*
+* @example
+* if (isErrorResult(result)) {
+*   console.error(result.error); // error is E, not undefined
+* }
+*/
+declare function isErrorResult<T, E = Error>(result: QueryResult<T, E> | QueryResultNullable<T, E>): result is (QueryResult<T, E> | QueryResultNullable<T, E>) & {
+  readonly isError: true;
+  readonly error: E;
+};
+/**
+* Type predicate to check if a query result is in idle state (not loading, no error, has data).
+*
+* @example
+* if (isIdle(result)) {
+*   // Safe to access and render data
+* }
+*/
+declare function isIdle<T, E = Error>(result: QueryResult<T, E> | QueryResultNullable<T, E>): boolean;
+/**
+* Type-safe property selector for hook results.
+* Uses K extends keyof T constraint (generics-function-constraints rule).
+*
+* @typeParam T - The data object type
+* @typeParam K - Key of T (constrained to actual keys)
+*
+* @example
+* const users = [{ name: "Alice", age: 30 }];
+* const names = selectProperty(users, "name"); // string[]
+* const ages = selectProperty(users, "age");   // number[]
+* selectProperty(users, "invalid"); // Error: "invalid" not in "name" | "age"
+*/
+declare function selectProperty<T, K extends keyof T>(items: readonly T[], key: K): T[K][];
+/**
+* Type-safe property getter for a single item.
+* Returns undefined if item is null/undefined.
+*
+* @typeParam T - The data object type
+* @typeParam K - Key of T (constrained to actual keys)
+*/
+declare function getProperty<T, K extends keyof T>(item: T | null | undefined, key: K): T[K] | undefined;
+/**
+* Generic type for hooks that fetch a single resource by ID.
+* Useful for creating consistent API across different resource types.
+*
+* @typeParam T - The resource type
+* @typeParam E - The error type (defaults to Error)
+*/
+type UseSingleResourceHook<T, E = Error> = (id: string) => QueryResultNullable<T, E>;
+/**
+* Generic type for hooks that fetch a list of resources with optional params.
+* Uses generics-default-type-parameters for the params type.
+*
+* @typeParam T - The item type
+* @typeParam P - The params type (defaults to empty object)
+* @typeParam E - The error type (defaults to Error)
+*/
+type UseListResourceHook<T, P extends Record<string, unknown> = Record<string, never>, E = Error> = (params?: P) => ListQueryResult<T, E>;
+/**
+* Transforms a nullable result to a non-nullable one if data exists.
+* Useful when you've already checked hasData().
+*/
+type WithData<R extends QueryResultNullable<unknown>> = R extends QueryResultNullable<infer T, infer E> ? QueryResultNullable<T, E> & {
+  readonly data: T;
+} : never;
+/**
+* Activity slug constants as a const object.
+* Derive the ActivitySlug type from this single source of truth.
+*/
+declare const ACTIVITY_SLUGS: {
+  readonly abandonedCart: "abandoned_cart";
+  readonly announcements: "announcements";
+  readonly cartItemsAdded: "cart_items_added";
+  readonly commentReply: "comment_reply";
+  readonly directMessage: "direct_message";
+  readonly fantasyPoint: "fantasy_point";
+  readonly newLead: "new_lead";
+  readonly orderPlaced: "order_placed";
+  readonly pageViews: "page_views";
+  readonly pageViewsContact: "page_views_contact";
+  readonly tasks: "tasks";
+  readonly upcomingEvent: "upcoming_event";
+  readonly video: "video";
+  readonly videoComplete: "video_complete";
+  readonly videoCompleteContact: "video_complete_contact";
+  readonly videoContact: "video_contact";
+  readonly messageReceived: "message_received";
+  readonly messageSent: "message_sent";
+  readonly newCartItemsAdded: "new_cart_items_added";
+  readonly smartLinkClicked: "smart_link_clicked";
+  readonly reviewLeft: "review_left";
+};
+/** Activity slug union type derived from ACTIVITY_SLUGS constant. */
+type ActivitySlug = (typeof ACTIVITY_SLUGS)[keyof typeof ACTIVITY_SLUGS];
+/** Type predicate to check if a string is a valid ActivitySlug. */
+declare function isActivitySlug(value: string): value is ActivitySlug;
+/** Transformed activity for display. */
+interface Activity {
+  readonly id: number;
+  readonly userName: string;
+  readonly avatarUrl: string | null;
+  readonly activityType: string;
+  readonly targetName: string;
+  readonly timestamp: string;
+  readonly slug: ActivitySlug;
+}
+/** Description/rich text metadata for a calendar event. */
+interface CalendarEventDescription {
+  readonly id?: number | null;
+  readonly name?: string | null;
+  readonly body?: string | null;
+  readonly record_type?: string | null;
+  readonly record_id?: number | null;
+  readonly created_at?: string | null;
+  readonly updated_at?: string | null;
+  readonly locale?: string | null;
+}
+/** Calendar event data from the API. */
+interface CalendarEvent {
+  readonly id: number;
+  readonly title: string;
+  readonly description?: CalendarEventDescription | null;
+  readonly color?: string | null;
+  readonly url?: string | null;
+  readonly start: string;
+  readonly end: string;
+  readonly active?: boolean | null;
+  readonly time_zone?: string | null;
+  readonly status?: string | null;
+  readonly image_url?: string | null;
+  readonly images?: readonly unknown[] | null;
+  readonly venue?: string | null;
+  readonly countries?: readonly string[] | null;
+  readonly hasTomorrow?: boolean | null;
+  readonly hasYesterday?: boolean | null;
+  readonly isAllDay?: boolean;
+}
+/** Catch up suggestion data from the API. */
+interface CatchUp {
+  readonly id: number;
+  readonly suggestion_title: string;
+}
+/** MySite data returned by the hook. */
+interface MySiteData {
+  readonly url: string | null;
+  readonly views: number;
+  readonly leads: number;
+  readonly userName: string;
+}
+/** Transformed todo for display. */
+interface Todo {
+  readonly id: number;
+  readonly body: string;
+  readonly dueAt: string | null;
+  readonly completedAt: string | null;
+  readonly createdAt: string;
+  readonly contactName: string | null;
+}
+//#endregion
+//#region src/hooks/use-calendar-events.d.ts
+/**
+* Result type for useCalendarEvents hook.
+* Uses QueryResult<CalendarEvent[]> with default Error type.
+*/
+type UseCalendarEventsResult = QueryResult<CalendarEvent[]>;
+/**
+* Hook to fetch calendar events.
+* This is a stub implementation - override with your own data fetching logic.
+*/
+declare function useCalendarEvents(): UseCalendarEventsResult;
+//#endregion
+//#region src/hooks/use-todos.d.ts
+/**
+* Result type for useTodos hook.
+* Uses QueryResult<Todo[]> with default Error type.
+*/
+type UseTodosResult = QueryResult<Todo[]>;
+/**
+* Hook to fetch todo items.
+* This is a stub implementation - override with your own data fetching logic.
+*/
+declare function useTodos(): UseTodosResult;
+//#endregion
+//#region src/hooks/use-activities.d.ts
+/**
+* Result type for useActivities hook.
+* Uses QueryResult generic with Activity[] and default Error type.
+*/
+type UseActivitiesResult = QueryResult<Activity[]>;
+/**
+* Hook to fetch recent activities.
+* This is a stub implementation - override with your own data fetching logic.
+*/
+declare function useActivities(): UseActivitiesResult;
+//#endregion
+//#region src/hooks/use-catchups.d.ts
+/**
+* Result type for useCatchUps hook.
+* Uses QueryResult<CatchUp[]> with default Error type.
+*/
+type UseCatchUpsResult = QueryResult<CatchUp[]>;
+/**
+* Hook to fetch catch up items.
+* This is a stub implementation - override with your own data fetching logic.
+*/
+declare function useCatchUps(): UseCatchUpsResult;
+//#endregion
+//#region src/hooks/use-mysite.d.ts
+/**
+* Result type for useMySite hook.
+* Uses QueryResultNullable since MySite data may not be available.
+*/
+type UseMySiteResult = QueryResultNullable<MySiteData>;
+/**
+* Hook to fetch MySite data.
+* This is a stub implementation - override with your own data fetching logic.
+*/
+declare function useMySite(): UseMySiteResult;
+//#endregion
+//#region src/hooks/use-conversations.d.ts
+/**
+* Result type for useConversations hook.
+* Uses QueryResult<Conversation[]> with default Error type.
+*/
+type UseConversationsResult = QueryResult<Conversation[]>;
+/**
+* Hook to fetch all conversations.
+* This is a stub implementation - override with your own data fetching logic.
+*
+* @returns UseConversationsResult with empty data array
+*
+* @example
+* ```tsx
+* const { data: conversations, isLoading, isError } = useConversations();
+*
+* if (isLoading) return <Loading />;
+* if (isError) return <Error />;
+*
+* return conversations.map(conv => <ConversationItem key={conv.id} {...conv} />);
+* ```
+*/
+declare function useConversations(): UseConversationsResult;
+/**
+* Result type for useConversationMessages hook.
+* Uses QueryResult<Message[]> with default Error type.
+*/
+type UseConversationMessagesResult = QueryResult<Message[]>;
+/**
+* Hook to fetch messages for a specific conversation.
+* This is a stub implementation - override with your own data fetching logic.
+*
+* @param conversationId - The ID of the conversation to fetch messages for
+* @returns UseConversationMessagesResult with empty data array
+*
+* @example
+* ```tsx
+* const { data: messages, isLoading, isError } = useConversationMessages(conversationId);
+*
+* if (isLoading) return <Loading />;
+* if (isError) return <Error />;
+*
+* return messages.map(msg => <MessageBubble key={msg.id} {...msg} />);
+* ```
+*/
+declare function useConversationMessages(_conversationId: string): UseConversationMessagesResult;
+//#endregion
+//#region src/hooks/use-contacts.d.ts
+/**
+* Type predicate to check if a status string is a valid ContactStatus.
+* Enables runtime validation with type narrowing.
+*/
+declare function isContactStatus(value: string): value is ContactStatus;
+/**
+* Parameters for filtering and paginating contacts.
+* Uses readonly properties and proper ContactStatus type for status.
+*/
+interface UseContactsParams {
+  /** Search query to filter contacts by name, email, or company */
+  readonly search?: string;
+  /** Filter contacts by status - uses ContactStatus union type for type safety */
+  readonly status?: ContactStatus;
+  /** Maximum number of contacts to return */
+  readonly limit?: number;
+}
+/**
+* Result type for the useContacts hook.
+* Uses ListQueryResult<Contact> with totalCount and default Error type.
+*/
+type UseContactsResult = ListQueryResult<Contact>;
+/**
+* Result type for the useContact hook.
+* Uses QueryResultNullable since a specific contact may not exist.
+*/
+type UseContactResult = QueryResultNullable<Contact>;
+/**
+* Hook to fetch a list of contacts with optional filtering and pagination.
+* This is a stub implementation - override with your own data fetching logic.
+*
+* @param params - Optional parameters for filtering and pagination
+* @returns Object containing contacts data, loading state, error state, and total count
+*
+* @example
+* ```tsx
+* const { data: contacts, isLoading, totalCount } = useContacts({
+*   search: 'john',
+*   status: 'active',
+*   limit: 20
+* });
+* ```
+*/
+declare function useContacts(_params?: UseContactsParams): UseContactsResult;
+/**
+* Hook to fetch a single contact by ID.
+* This is a stub implementation - override with your own data fetching logic.
+*
+* @param contactId - The unique identifier of the contact to fetch
+* @returns Object containing contact data, loading state, and error state
+*
+* @example
+* ```tsx
+* const { data: contact, isLoading, isError } = useContact('contact-123');
+* ```
+*/
+declare function useContact(_contactId: string): UseContactResult;
+//#endregion
+//#region src/components/RequireAuth.d.ts
+interface RequireAuthProps {
+  /** Content to render when authenticated */
+  children: ReactNode;
+  /** Component to show while checking authentication (default: AuthLoading) */
+  fallback?: ReactNode;
+  /** Component to show when not authenticated (default: AuthError) */
+  errorComponent?: ReactNode;
+}
+/**
+* Component that protects content requiring authentication.
+*
+* **Important:** This provides UX-level protection only. It prevents
+* unauthenticated users from seeing the UI, but the real security
+* boundary is the server-side API. Client-side auth can always be
+* bypassed by modifying browser state.
+*
+* For defense-in-depth, configure `jwksUrl` in `FluidAuthConfig`
+* to enable client-side JWT signature verification.
+*
+* Shows different states based on auth status:
+* - Loading: Shows fallback (spinner by default)
+* - Not authenticated: Shows errorComponent (AuthError by default)
+* - Authenticated: Shows children
+*
+* @example
+* ```tsx
+* // Basic usage - shows default loading/error states
+* <RequireAuth>
+*   <ProtectedContent />
+* </RequireAuth>
+*
+* // Custom loading state
+* <RequireAuth fallback={<CustomSpinner />}>
+*   <ProtectedContent />
+* </RequireAuth>
+*
+* // Custom error component
+* <RequireAuth errorComponent={<LoginPrompt />}>
+*   <ProtectedContent />
+* </RequireAuth>
+*
+* // Both custom
+* <RequireAuth
+*   fallback={<SkeletonLoader />}
+*   errorComponent={<RedirectToLogin />}
+* >
+*   <Dashboard />
+* </RequireAuth>
+* ```
+*/
+declare function RequireAuth({
+  children,
+  fallback,
+  errorComponent
+}: RequireAuthProps): React.JSX.Element;
+//#endregion
+//#region src/components/AuthError.d.ts
+interface AuthErrorProps {
+  /** Error message to display */
+  message?: string;
+  /** Optional title */
+  title?: string;
+  /** Optional children for custom content */
+  children?: ReactNode;
+}
+/**
+* Default authentication error component.
+*
+* Displays a simple error message when authentication fails.
+* Can be customized via props or replaced entirely in RequireAuth.
+*
+* @example
+* ```tsx
+* // Use with default message
+* <AuthError />
+*
+* // Use with custom message
+* <AuthError message="Session expired. Please log in again." />
+*
+* // Use with custom content
+* <AuthError>
+*   <CustomLoginButton />
+* </AuthError>
+* ```
+*/
+declare function AuthError({
+  message,
+  title,
+  children
+}: AuthErrorProps): React.JSX.Element;
+/**
+* Simple loading spinner component for auth loading state.
+*/
+declare function AuthLoading(): React.JSX.Element;
+//#endregion
+//#region src/messaging/use-messaging-auth.d.ts
+declare function useMessagingAuth(): MessagingAuthContext$1;
+//#endregion
+//#region src/messaging/use-messaging-config.d.ts
+interface MessagingConfig {
+  readonly apiConfig: MessagingApiConfig;
+  readonly websocketUrl: string;
+  readonly token: string | null;
+}
+declare function useMessagingConfig(): MessagingConfig;
+//#endregion
+//#region src/messaging/fluid-file-uploader.d.ts
+/**
+* Creates a FileUploader that uploads to Filestack using the REST API.
+*
+* @param apiKey - Filestack API key. If falsy, returns a noop uploader
+*                 that rejects uploads with a helpful error message.
+*/
+declare function createFluidFileUploader(apiKey: string | undefined): FileUploader$1;
+import * as import__fluid_app_portal_core_theme from "@fluid-app/portal-core/theme";
+//#endregion
+//#region src/screens/MessagingScreen.d.ts
+type MessagingScreenProps = ComponentProps<"div"> & {
+  background?: BackgroundValue;
+  textColor?: ColorOptions;
+  accentColor?: ColorOptions;
+  padding?: PaddingOptions;
+  borderRadius?: BorderRadiusOptions;
+  onToast?: (message: string, type: "success" | "error") => void;
+  filestackApiKey?: string;
+  websocketUrl?: string;
+};
+declare function MessagingScreen({
+  onToast,
+  filestackApiKey,
+  websocketUrl: websocketUrlOverride,
+  background,
+  textColor,
+  accentColor,
+  padding,
+  borderRadius,
+  ...divProps
+}: MessagingScreenProps): React.JSX.Element;
+declare const messagingScreenPropertySchema: WidgetPropertySchema;
+//#endregion
+//#region src/screens/ContactsScreen.d.ts
+type ContactsScreenProps = ComponentProps<"div"> & {
+  background?: BackgroundValue;
+  textColor?: ColorOptions;
+  accentColor?: ColorOptions;
+  padding?: PaddingOptions;
+  borderRadius?: BorderRadiusOptions;
+  defaultViewMode?: "list" | "grid";
+  onContactSelect?: (contactId: string) => void;
+  onCreateContact?: () => void;
+};
+declare function ContactsScreen(_props: ContactsScreenProps): React.JSX.Element;
+declare const contactsScreenPropertySchema: WidgetPropertySchema;
+//#endregion
+//#region src/screens/OrdersScreen.d.ts
+type OrdersScreenProps = ComponentProps<"div"> & {
+  background?: BackgroundValue;
+  textColor?: ColorOptions;
+  accentColor?: ColorOptions;
+  padding?: PaddingOptions;
+  borderRadius?: BorderRadiusOptions;
+};
+declare function OrdersScreen(_props: OrdersScreenProps): React.JSX.Element;
+declare const ordersScreenPropertySchema: WidgetPropertySchema;
+//#endregion
+//#region src/screens/CustomersScreen.d.ts
+type CustomersScreenProps = ComponentProps<"div"> & {
+  background?: BackgroundValue;
+  textColor?: ColorOptions;
+  accentColor?: ColorOptions;
+  padding?: PaddingOptions;
+  borderRadius?: BorderRadiusOptions;
+};
+declare function CustomersScreen(_props: CustomersScreenProps): React.JSX.Element;
+declare const customersScreenPropertySchema: WidgetPropertySchema;
+//#endregion
+//#region src/screens/ProductsScreen.d.ts
+type ProductsScreenProps = ComponentProps<"div"> & {
+  background?: BackgroundValue;
+  textColor?: ColorOptions;
+  accentColor?: ColorOptions;
+  padding?: PaddingOptions;
+  borderRadius?: BorderRadiusOptions;
+};
+declare function ProductsScreen(_props: ProductsScreenProps): React.JSX.Element;
+declare const productsScreenPropertySchema: WidgetPropertySchema;
+//#endregion
+//#region src/screens/index.d.ts
+declare const screenPropertySchemas: Record<string, () => Promise<WidgetPropertySchema>>;
+/**
+* Core page template IDs
+*/
+declare const CORE_PAGE_IDS: {
+  readonly MESSAGING: "core-messaging";
+  readonly CONTACTS: "core-contacts";
+  readonly ORDERS: "core-orders";
+  readonly CUSTOMERS: "core-customers";
+  readonly PRODUCTS: "core-products";
+};
+//#endregion
+//#region src/core/default-widget-registry.d.ts
+declare const DEFAULT_SDK_WIDGET_REGISTRY: WidgetRegistry$1;
+//#endregion
+//#region src/core/resolve-pages.d.ts
+/**
+* Resolve all page references and local screens into a unified screen list.
+*
+* This function merges:
+* 1. Screen definitions from page_refs (shared templates)
+* 2. Local screen definitions (for backwards compatibility and custom screens)
+*
+* When a screen_id appears in both page_refs and screens, the local screen
+* takes precedence (allows local overrides of template pages).
+*
+* @param navigation - The navigation configuration
+* @returns A unified array of ScreenDefinition objects
+*
+* @example
+* ```ts
+* const navigation: Navigation = {
+*   definition_id: 1,
+*   id: 1,
+*   name: "Main Nav",
+*   navigation_items: [...],
+*   screens: [
+*     // Local custom screen
+*     { id: 1, slug: "home", name: "Home", component_tree: [...] }
+*   ],
+*   page_refs: [
+*     // Reference to shared messaging template
+*     { page_template_id: "core-messaging", screen_id: 2 }
+*   ],
+* };
+*
+* const allScreens = resolveNavigationPages(navigation);
+* // Returns: [home screen, messaging screen from template]
+* ```
+*/
+declare function resolveNavigationPages(navigation: Readonly<Navigation>): ScreenDefinition[];
+/**
+* Get all available page templates for use in navigation.
+*
+* @returns Array of page templates from the registry
+*/
+declare function getAvailablePageTemplates(): PageTemplate[];
+/**
+* Get core page templates that are required for basic functionality.
+*
+* @returns Array of core page templates
+*/
+declare function getCorePageTemplates(): PageTemplate[];
+/**
+* Get optional page templates that can be added to navigation.
+*
+* @returns Array of optional (non-core) page templates
+*/
+declare function getOptionalPageTemplates(): PageTemplate[];
+/**
+* Check if a navigation has all required core pages.
+*
+* @param navigation - The navigation to check
+* @returns Object with validation result and missing page IDs
+*/
+declare function validateNavigationPages(navigation: Readonly<Navigation>): {
+  readonly valid: boolean;
+  readonly missingCorePages: readonly string[];
+};
+//#endregion
+//#region src/registries/page-template-registry.d.ts
+/**
+* Registry for managing reusable page templates.
+*
+* The registry provides a central store for page templates that can be
+* shared across multiple navigations. Core pages (like Messaging, Contacts)
+* are pre-registered and cannot be removed.
+*
+* @example
+* ```ts
+* // Register a custom page template
+* PageTemplateRegistry.register({
+*   id: 'custom-dashboard',
+*   slug: 'dashboard',
+*   name: 'Custom Dashboard',
+*   category: 'custom',
+*   version: '1.0.0',
+*   component_tree: [{ type: 'TextWidget', props: { text: 'Hello' } }],
+* });
+*
+* // Get a template by ID
+* const template = PageTemplateRegistry.get('custom-dashboard');
+*
+* // List all templates in a category
+* const corePages = PageTemplateRegistry.getByCategory('core');
+* ```
+*/
+declare class PageTemplateRegistryImpl {
+  private templates;
+  private categories;
+  constructor();
+  /**
+  * Register a new page template.
+  * @throws Error if a template with the same ID already exists
+  */
+  register(template: PageTemplate): void;
+  /**
+  * Unregister a page template by ID.
+  * Core templates cannot be unregistered.
+  * @returns true if the template was removed, false if it didn't exist or is a core template
+  */
+  unregister(id: string): boolean;
+  /**
+  * Get a page template by ID.
+  */
+  get(id: string): PageTemplate | undefined;
+  /**
+  * Get all page templates in a specific category.
+  */
+  getByCategory(category: PageCategoryId | string): PageTemplate[];
+  /**
+  * List all registered page templates.
+  */
+  listAll(): PageTemplate[];
+  /**
+  * List all core page templates (isCore: true).
+  */
+  listCore(): PageTemplate[];
+  /**
+  * List all non-core page templates.
+  */
+  listOptional(): PageTemplate[];
+  /**
+  * List all registered categories.
+  */
+  listCategories(): PageCategory[];
+  /**
+  * Add a custom category.
+  */
+  addCategory(category: PageCategory): void;
+  /**
+  * Check if a template exists by ID.
+  */
+  has(id: string): boolean;
+  /**
+  * Get the count of registered templates.
+  */
+  get size(): number;
+  /**
+  * Clear all non-core templates.
+  * Useful for testing or resetting the registry.
+  */
+  clearNonCore(): void;
+}
+/**
+* Global page template registry singleton.
+*
+* This registry is automatically populated with core page templates
+* (Messaging, Contacts) when the SDK is imported.
+*/
+declare const PageTemplateRegistry: PageTemplateRegistryImpl;
+//#endregion
+//#region src/shell/AppShell.d.ts
+interface AppShellProps {
+  /** Pre-fetched app data (skips internal useFluidApp call if provided) */
+  appData?: RepAppData$1;
+  /** Override navigation items (otherwise derived from appData/API) */
+  navigation?: NavigationItem[];
+  /** Custom page components keyed by slug */
+  customPages?: Record<string, ComponentType<{
+    slug?: string;
+    params?: string;
+  }>>;
+  /** Base path for subpath deployments (e.g. "/portal"). Default: "/" */
+  basePath?: string;
+  /** Controlled current slug */
+  currentSlug?: string;
+  /** Navigation callback */
+  onNavigate?: (slug: string) => void;
+  /** Custom sidebar header slot */
+  sidebarHeader?: ReactNode;
+  /** Custom sidebar footer slot */
+  sidebarFooter?: ReactNode;
+  /** Render prop or static children for the content area */
+  children?: ReactNode | ((props: {
+    currentSlug: string;
+    currentNavItem: NavigationItem | undefined;
+  }) => ReactNode);
+}
+declare function AppShell({
+  appData: appDataProp,
+  navigation: navigationProp,
+  customPages,
+  basePath,
+  currentSlug: controlledSlug,
+  onNavigate: onNavigateProp,
+  sidebarHeader,
+  sidebarFooter,
+  children
+}: AppShellProps): React.JSX.Element;
+//#endregion
+//#region src/shell/BuilderScreenView.d.ts
+interface BuilderScreenViewProps {
+  /** The screen definition to render */
+  screen: ScreenDefinition$1;
+  /** Additional CSS classes for the wrapper div */
+  className?: string;
+}
+/**
+* Renders a builder screen's component_tree with full data source support.
+* Widgets with `dataSource` config are automatically wrapped with `DataAwareWidget`
+* which fetches data and merges it with static props before rendering.
+*/
+declare function BuilderScreenViewImpl({
+  screen,
+  className
+}: BuilderScreenViewProps): React$1.JSX.Element | null;
+declare const BuilderScreenView: React$1.MemoExoticComponent<typeof BuilderScreenViewImpl>;
+//#endregion
+//#region src/shell/SdkNavigation.d.ts
+interface SdkNavigationProps {
+  navItems: NavigationItem[];
+  currentSlug: string;
+  onNavigate: (slug: string) => void;
+  navSlugs: string[];
+}
+declare function SdkNavigation({
+  navItems,
+  currentSlug,
+  onNavigate,
+  navSlugs
+}: SdkNavigationProps): React.JSX.Element;
+//#endregion
+//#region src/shell/SdkHeader.d.ts
+interface SdkHeaderProps {
+  tabs: NavigationItem[];
+  mobileTabs?: NavigationItem[];
+  currentSlug: string;
+  onNavigate: (slug: string) => void;
+  navSlugs: string[];
+}
+declare function SdkHeader({
+  tabs,
+  mobileTabs,
+  currentSlug,
+  onNavigate,
+  navSlugs
+}: SdkHeaderProps): React.JSX.Element;
+//#endregion
+//#region src/shell/PageRouter.d.ts
+interface PageRouterProps {
+  currentSlug: string;
+  currentNavItem?: NavigationItem | undefined;
+  customPages?: Record<string, ComponentType<{
+    slug?: string;
+    params?: string;
+  }>> | undefined;
+  /** Builder screen definitions (from fluidos API) */
+  screens?: ScreenDefinition[] | undefined;
+  baseSlug: string;
+  restParams: string;
+}
+declare function PageRouter({
+  currentSlug,
+  currentNavItem,
+  customPages,
+  screens,
+  baseSlug,
+  restParams
+}: PageRouterProps): React.JSX.Element;
+//#endregion
+//#region src/shell/QuickLinksDropdown.d.ts
+interface QuickLinksDropdownProps {
+  onNavigate: (slug: string) => void;
+}
+declare function QuickLinksDropdown({
+  onNavigate
+}: QuickLinksDropdownProps): React.JSX.Element;
+//#endregion
+//#region src/shell/AppNavigationContext.d.ts
+interface AppNavigationContextValue {
+  /** Current active slug (e.g. "contacts/123") */
+  currentSlug: string;
+  /** Base path for subpath deployments (e.g. "/portal"). Default: "/" */
+  basePath: string;
+  /** Navigate to a slug programmatically */
+  navigate: (slug: string) => void;
+  /** Build a full href for a slug (for use in <a> tags) */
+  buildHref: (slug: string) => string;
+}
+interface AppNavigationProviderProps {
+  currentSlug: string;
+  basePath: string;
+  navigate: (slug: string) => void;
+  children: ReactNode;
+}
+declare function AppNavigationProvider({
+  currentSlug,
+  basePath,
+  navigate,
+  children
+}: AppNavigationProviderProps): React.JSX.Element;
+declare function useAppNavigation(): AppNavigationContextValue;
+//#endregion
+//#region src/shell/AppLink.d.ts
+interface AppLinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href"> {
+  /** Slug to navigate to (e.g. "contacts/123") */
+  to: string;
+}
+/**
+* SPA-aware link that renders a real `<a href>` for accessibility
+* (right-click, ctrl+click, screen readers) but intercepts normal
+* clicks for client-side navigation.
+*/
+declare const AppLink: React$1.ForwardRefExoticComponent<AppLinkProps & React$1.RefAttributes<HTMLAnchorElement>>;
+//#endregion
+//#region src/shell/slug-utils.d.ts
+interface SlugMatch {
+  matchedSlug: string;
+  rest: string;
+}
+/**
+* Extract all slugs from a navigation tree, sorted by segment count descending.
+* Longest slugs first enables greedy prefix matching (e.g. "share/playlists"
+* is checked before "share").
+*/
+declare function collectNavSlugs(items: NavigationItem[]): string[];
+/**
+* Find the longest registered nav slug that is a prefix of `fullSlug`.
+* Uses segment-boundary checking to prevent "shop" from matching "shopping".
+*/
+declare function matchSlugPrefix(fullSlug: string, navSlugs: string[]): SlugMatch | undefined;
+/**
+* Extract the slug portion from a full pathname by stripping the basePath prefix.
+* Returns an empty string when the pathname equals the basePath exactly.
+*
+* Examples:
+*   extractSlugFromPathname("/contacts/123", "/")        → "contacts/123"
+*   extractSlugFromPathname("/portal/contacts", "/portal") → "contacts"
+*   extractSlugFromPathname("/portal", "/portal")          → ""
+*   extractSlugFromPathname("/", "/")                      → ""
+*/
+declare function extractSlugFromPathname(pathname: string, basePath: string): string;
+declare function isSlugInSection(item: NavigationItem, currentSlug: string, navSlugs: string[]): boolean;
+type DEFAULT_COLORS = import__fluid_app_portal_core_theme.DEFAULT_COLORS;
+type DEFAULT_FONT_FAMILIES = import__fluid_app_portal_core_theme.DEFAULT_FONT_FAMILIES;
+type DEFAULT_FONT_SIZES = import__fluid_app_portal_core_theme.DEFAULT_FONT_SIZES;
+type DEFAULT_RADII = import__fluid_app_portal_core_theme.DEFAULT_RADII;
+type DEFAULT_SPACING = import__fluid_app_portal_core_theme.DEFAULT_SPACING;
+type DEFAULT_THEME_ID = import__fluid_app_portal_core_theme.DEFAULT_THEME_ID;
+type DEFAULT_THEME_NAME = import__fluid_app_portal_core_theme.DEFAULT_THEME_NAME;
+type FONT_FAMILY_KEYS = import__fluid_app_portal_core_theme.FONT_FAMILY_KEYS;
+type FONT_SIZE_KEYS = import__fluid_app_portal_core_theme.FONT_SIZE_KEYS;
+type FontFamilyKey = import__fluid_app_portal_core_theme.FontFamilyKey;
+type FontSizeKey = import__fluid_app_portal_core_theme.FontSizeKey;
+type GenerateThemeCSSOptions = import__fluid_app_portal_core_theme.GenerateThemeCSSOptions;
+type OklchPlain = import__fluid_app_portal_core_theme.OklchPlain;
+type RADIUS_KEYS = import__fluid_app_portal_core_theme.RADIUS_KEYS;
+type RadiusKey = import__fluid_app_portal_core_theme.RadiusKey;
+type ResolvedColorSet = import__fluid_app_portal_core_theme.ResolvedColorSet;
+type ResolvedSemanticColor = import__fluid_app_portal_core_theme.ResolvedSemanticColor;
+type SEMANTIC_COLOR_NAMES = import__fluid_app_portal_core_theme.SEMANTIC_COLOR_NAMES;
+type SHADE_STEPS = import__fluid_app_portal_core_theme.SHADE_STEPS;
+type SemanticColorName = import__fluid_app_portal_core_theme.SemanticColorName;
+type ShadeStep = import__fluid_app_portal_core_theme.ShadeStep;
+type ThemeColorPlain = import__fluid_app_portal_core_theme.ThemeColorPlain;
+type applyTheme = import__fluid_app_portal_core_theme.applyTheme;
+type deriveDarkVariant = import__fluid_app_portal_core_theme.deriveDarkVariant;
+type deserialiseTheme = import__fluid_app_portal_core_theme.deserialiseTheme;
+type generateShades = import__fluid_app_portal_core_theme.generateShades;
+type generateThemeCSS = import__fluid_app_portal_core_theme.generateThemeCSS;
+type getDefaultThemeDefinition = import__fluid_app_portal_core_theme.getDefaultThemeDefinition;
+type getForegroundColor = import__fluid_app_portal_core_theme.getForegroundColor;
+type mergeDarkOverrides = import__fluid_app_portal_core_theme.mergeDarkOverrides;
+type parseColor = import__fluid_app_portal_core_theme.parseColor;
+type removeAllThemes = import__fluid_app_portal_core_theme.removeAllThemes;
+type removeTheme = import__fluid_app_portal_core_theme.removeTheme;
+type resolveTheme = import__fluid_app_portal_core_theme.resolveTheme;
+type serialiseTheme = import__fluid_app_portal_core_theme.serialiseTheme;
+export { ACTIVITY_SLUGS, APP_DATA_QUERY_KEY, AUTH_CONSTANTS, type Activity as ActivityItem, type ActivitySlug, AlertWidget, type AlignOptions, ApiError, AppLink, type AppLinkProps, type AppNavigationContextValue, AppNavigationProvider, type AppNavigationProviderProps, AppShell, type AppShellProps, AuthError, type AuthErrorProps, AuthLoading, type BackgroundType, type BackgroundValue, type BaseListParams, type BorderRadiusOptions, BuilderScreenView, type BuilderScreenViewProps, type ButtonSizeOptions, CORE_PAGE_IDS, CURRENT_REP_QUERY_KEY, type CalendarEvent, CalendarWidget, CarouselWidget, type CatchUp as CatchUpItem, CatchUpWidget, ChartWidget, type ColorOptions, type Contact, type ContactAddress, type ContactStatus, type ContactType, ContactsScreen, ContainerWidget, type Conversation, type ConversationStatus, type CreateOrderData, CustomersScreen, DEFAULT_AUTH_URL, DEFAULT_COLORS, DEFAULT_FONT_FAMILIES, DEFAULT_FONT_SIZES, DEFAULT_RADII, DEFAULT_SDK_WIDGET_REGISTRY, DEFAULT_SPACING, DEFAULT_THEME_ID, DEFAULT_THEME_NAME, type DashboardData, EmbedWidget, FONT_FAMILY_KEYS, FONT_SIZE_KEYS, type FileUploader, type FluidAuthConfig, type FluidAuthContextValue, FluidAuthProvider, type FluidAuthProviderProps, type FluidClient, FluidProvider, type FluidProviderProps, type FluidSDKConfig, FluidThemeProvider, type FluidThemeProviderProps, type FontFamilyKey, type FontSizeKey, type FontSizeOptions, type GapOptions, type GenerateThemeCSSOptions, ImageWidget, type JWTPayload, LayoutWidget, type ListQueryResult, ListWidget, type Message, type MessageType, type MessagingAuthContext, type MessagingConfig, type MessagingCurrentUser, MessagingScreen, type MySiteData, MySiteWidget, type Navigation, type NavigationItem, NestedWidget, type OklchPlain, type Order, type OrderLineItem, type OrderListParams, OrdersScreen, PAGE_CATEGORIES, PERMISSIONS_QUERY_KEY, PROFILE_QUERY_KEY, PROPERTY_FIELD_TYPES, type PaddingOptions, type PageCategory, type PageCategoryId, type PageOverride, type PageReference, PageRouter, type PageRouterProps, type PageTemplate, PageTemplateProvider, PageTemplateRegistry, type PaginationParams, type Participant, type PermissionAction, type Permissions, type Product, type ProductListParams, ProductsScreen, type Profile, type PropertyFieldSchema, type PropertyFieldType, type QueryResult, type QueryResultNullable, QuickLinksDropdown, type QuickLinksDropdownProps, QuickShareWidget, RADIUS_KEYS, type RadiusKey, type RawApiNavigationItem, type RawApiScreen, type RawApiTheme, type RawManifestResponse, RecentActivityWidget, type Rep, type RepAppData, type RepAppManifest, type RepAppProfile, type RequestOptions, RequireAuth, type RequireAuthProps, type ResolvedColorSet, type ResolvedSemanticColor, type ResolvedTheme, type ResourcePermissions, SEMANTIC_COLOR_NAMES, SHADE_STEPS, STORAGE_KEYS, type SalesData, type SalesDataPoint, type SalesParams, type ScreenDefinition, SdkHeader, type SdkHeaderProps, SdkNavigation, type SdkNavigationProps, type SectionLayoutType, type SemanticColorName, type ShadeStep, type ShareableItem, type SlugMatch, SpacerWidget, type TabConfig, TableWidget, TextWidget, type ThemeColorInput, type ThemeColorPlain, type ThemeDefinition, type ThemeMode, ThemeModeProvider, type ThemePayload, ToDoWidget, type Todo as TodoItem, type TokenValidationResult, type TypedWidgetSchema, URL_PARAMS, USER_TYPES, type UpdateRepData, type UploadCallbacks, type UploadResult, type UseContactResult, type UseContactsParams, type UseContactsResult, type UseConversationMessagesResult, type UseConversationsResult, type UseFluidPermissionsResult, type UseFluidThemeResult, type UseListResourceHook, type UseSingleResourceHook, type UserMe, type UserPermissions, type UserType, type ValueListQueryResult, VideoWidget, WIDGET_TYPE_NAMES, type WidgetPath, type WidgetPropertySchema, type WidgetRegistry, type WidgetSchema, type WidgetType, type WidgetTypeName, type WithData, alertWidgetPropertySchema, applyTheme, assertDefined, assertNever, buildThemeDefinition, calendarWidgetPropertySchema, carouselWidgetPropertySchema, catchUpWidgetPropertySchema, chartWidgetPropertySchema, cleanTokenFromUrl, clearTokens, collectNavSlugs, contactsScreenPropertySchema, containerWidgetPropertySchema, createDefaultAuthRedirect, createFluidClient, createFluidFileUploader, createScreen, createWidgetFromShareable, createWidgetRegistry, customersScreenPropertySchema, decodeToken, deriveDarkVariant, deserialiseTheme, embedWidgetPropertySchema, extractAllTokensFromUrl, extractCompanyTokenFromUrl, extractSlugFromPathname, extractTokenFromUrl, gapValues, generateShades, generateThemeCSS, getActiveThemeId, getAvailablePageTemplates, getCorePageTemplates, getDefaultThemeDefinition, getForegroundColor, getOptionalPageTemplates, getProperty, getStoredToken, getThemeModeAttribute, getTokenExpiration, getTokenTimeRemaining, groupChildrenByColumn, hasData, hasStoredToken, hasTokenInUrl, imageWidgetPropertySchema, isActivitySlug, isApiError, isContactStatus, isErrorResult, isIdle, isLoading, isPropertyFieldType, isSlugInSection, isTokenExpired, isUserType, isValidToken, isWidgetType, isWidgetTypeName, layoutWidgetPropertySchema, listWidgetPropertySchema, matchSlugPrefix, mergeDarkOverrides, messagingScreenPropertySchema, mySiteWidgetPropertySchema, nestedWidgetPropertySchema, normalizeComponentTree, ordersScreenPropertySchema, parseColor, productsScreenPropertySchema, quickShareWidgetPropertySchema, recentActivityWidgetPropertySchema, removeAllThemes, removeTheme, resolveNavigationPages, resolveTheme, screenPropertySchemas, sectionLayoutConfig, selectProperty, serialiseTheme, spacerWidgetPropertySchema, storeToken, tableWidgetPropertySchema, textWidgetPropertySchema, toDoWidgetPropertySchema, toNavigationItem, toScreenDefinition, transformManifestToRepAppData, transformThemes, useActivities, useAppNavigation, useCalendarEvents, useCatchUps, useContact, useContacts, useConversationMessages, useConversations, useCurrentRep, useFluidApi, useFluidApp, useFluidAuth, useFluidAuthContext, useFluidContext, useFluidPermissions, useFluidProfile, useFluidTheme, useMessagingAuth, useMessagingConfig, useMySite, usePageTemplates, useResolvedPages, useThemeContext, useThemeMode, useTodos, validateNavigationPages, validateToken, videoWidgetPropertySchema, widgetPropertySchemas };
+//# sourceMappingURL=index.d.cts.map