@fluid-app/rep-sdk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,2164 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React, { ReactNode, ComponentProps } from 'react';
+import { QueryClient, UseQueryResult } from '@tanstack/react-query';
+import { WidgetSchema, Theme, BackgroundValue, ColorOptions, PaddingOptions, BorderRadiusOptions } from '@fluid-app/rep-core/types';
+export { AlignOptions, BackgroundType, BackgroundValue, BorderRadiusOptions, ButtonSizeOptions, ColorOptions, FontSizeOptions, GapOptions, PaddingOptions, SectionLayoutType, ShareableItem, Theme, TypedWidgetSchema, WIDGET_TYPE_NAMES, WidgetPath, WidgetRegistry, WidgetSchema, WidgetType, WidgetTypeName, assertDefined, assertNever, isWidgetType, isWidgetTypeName, sectionLayoutConfig } from '@fluid-app/rep-core/types';
+export { BUILT_IN_THEMES, CORE_COLOR_KEYS, CoreColors, DEFAULT_CORE_COLORS, Oklch, ThemeConfig, catppuccinMocha, clampChroma, defaultTheme, detectThemeMode, dracula, everforest, generateColorSwatches, generateDualTheme, generateSmartDualTheme, generateTheme, generateThemeCssVars, gruvbox, mod, monokai, nord, oklchString, parseOklch, rosePine, rotateHue, rotateSoft, solarized, toDarkMode, toLightMode, tokyoNight } from '@fluid-app/rep-core/theme';
+export { 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/rep-widgets/widgets';
+import * as _fluid_app_rep_core_registries from '@fluid-app/rep-core/registries';
+import { WidgetPropertySchema } from '@fluid-app/rep-core/registries';
+export { PROPERTY_FIELD_TYPES, PropertyFieldSchema, PropertyFieldType, TabConfig, WidgetPropertySchema, gapValues, isPropertyFieldType } from '@fluid-app/rep-core/registries';
+export { createScreen, createWidgetFromShareable, createWidgetRegistry, groupChildrenByColumn } from '@fluid-app/rep-core/widget-utils';
+
+/**
+ * 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;
+}
+
+/**
+ * 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];
+
+/**
+ * Navigation item in the sidebar/menu structure
+ */
+interface NavigationItem {
+    /** Database-generated identifier */
+    readonly id?: number;
+    /** URL slug for routing */
+    slug?: string;
+    /** Display label */
+    label: string;
+    /** Icon identifier (e.g., FontAwesome name) */
+    icon?: string;
+    /** Associated screen ID */
+    screen_id?: number;
+    /** Sort order */
+    position?: number;
+    /** Parent navigation item ID (null for root items) */
+    parent_id?: number | null;
+    /** Nested navigation items */
+    children: NavigationItem[];
+}
+/**
+ * Screen definition with its component tree
+ */
+interface ScreenDefinition {
+    readonly id: number;
+    slug: string;
+    name: string;
+    component_tree: WidgetSchema[];
+}
+/**
+ * Navigation configuration for the rep portal
+ */
+interface Navigation {
+    readonly definition_id: number;
+    readonly id: number;
+    name: string;
+    navigation_items: NavigationItem[];
+    /** Local screen definitions (for backwards compatibility and custom screens) */
+    screens: ScreenDefinition[];
+    /** References to shared page templates from the registry */
+    page_refs?: PageReference[];
+}
+
+/**
+ * Rep portal profile containing themes and navigation configuration
+ */
+interface Profile {
+    /** Profile name */
+    name: string;
+    /** Available themes for the portal */
+    themes: Theme[];
+    /** Navigation structure and screens */
+    navigation: Navigation;
+    /** Portal definition ID */
+    readonly definition_id: number;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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 all API requests (e.g., "https://api.fluid.app/api")
+     */
+    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": "rep-portal" }
+     */
+    readonly defaultHeaders?: Readonly<Record<string, 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;
+}
+
+/**
+ * Fluid API Client
+ * Adapted from: packages/fluidos-api-client/src/lib/fetch-client.ts
+ * Provides authenticated API access with domain-specific methods
+ */
+
+/**
+ * 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;
+}
+/**
+ * Creates a configured Fluid API client instance
+ */
+declare function createFluidClient(config: FluidSDKConfig): {
+    request: <TResponse = unknown>(endpoint: string, options?: RequestOptions) => Promise<TResponse>;
+    requestNullable: <TResponse>(endpoint: string, options?: RequestOptions) => Promise<TResponse | null>;
+    safeRequest: <TResponse>(endpoint: string, options?: RequestOptions) => Promise<ApiResult<TResponse>>;
+    get: <TResponse = unknown, TParams extends object = Record<string, unknown>>(endpoint: string, params?: TParams, options?: Omit<RequestOptions, "method" | "params">) => Promise<TResponse>;
+    post: <TResponse = unknown>(endpoint: string, body?: unknown, options?: Omit<RequestOptions, "method" | "body">) => Promise<TResponse>;
+    put: <TResponse = unknown>(endpoint: string, body?: unknown, options?: Omit<RequestOptions, "method" | "body">) => Promise<TResponse>;
+    patch: <TResponse = unknown>(endpoint: string, body?: unknown, options?: Omit<RequestOptions, "method" | "body">) => Promise<TResponse>;
+    delete: <TResponse = unknown>(endpoint: string, options?: Omit<RequestOptions, "method">) => Promise<TResponse>;
+    products: {
+        list: (params?: ProductListParams) => Promise<ProductsResponse>;
+        get: (id: string | number) => Promise<{
+            product: Product;
+        }>;
+        search: (query: string, params?: ProductListParams) => Promise<ProductsResponse>;
+    };
+    orders: {
+        list: (params?: OrderListParams) => Promise<Order[]>;
+        get: (id: string) => Promise<Order>;
+        create: (data: CreateOrderData) => Promise<Order>;
+    };
+    reps: {
+        current: () => Promise<Rep>;
+        updateProfile: (data: UpdateRepData) => Promise<Rep>;
+    };
+    profile: {
+        get: () => Promise<Profile>;
+    };
+    permissions: {
+        get: () => Promise<UserPermissions>;
+    };
+    analytics: {
+        dashboard: () => Promise<DashboardData>;
+        sales: (params?: SalesParams) => Promise<SalesData>;
+    };
+};
+type FluidClient = ReturnType<typeof createFluidClient>;
+
+/**
+ * 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?: Theme;
+    /** Optional container for scoped theme application */
+    themeContainer?: HTMLElement | null;
+}
+/**
+ * Main provider for the Fluid Rep SDK
+ *
+ * @example
+ * ```tsx
+ * import { FluidProvider } from "@fluid-app/rep-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, }: FluidProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access the Fluid context
+ * Must be used within a FluidProvider
+ */
+declare function useFluidContext(): FluidContextValue;
+
+/**
+ * Context value for theme management.
+ * All properties are readonly since context values should not be mutated by consumers.
+ */
+interface ThemeContextValue {
+    /** Currently active theme */
+    readonly currentTheme: Theme | null;
+    /** Switch to a different theme */
+    readonly setTheme: (theme: Theme) => void;
+    /** Switch between light and dark mode for the current theme */
+    readonly setThemeMode: (mode: "light" | "dark") => void;
+}
+interface FluidThemeProviderProps {
+    children: ReactNode;
+    /** Initial theme to apply */
+    initialTheme?: Theme;
+    /** Container element for scoped theme application (defaults to document.documentElement) */
+    container?: HTMLElement | null;
+}
+declare function FluidThemeProvider({ children, initialTheme, container, }: FluidThemeProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access theme context
+ * Must be used within a FluidThemeProvider
+ */
+declare function useThemeContext(): ThemeContextValue;
+
+/**
+ * Auth Types for Fluid Rep SDK
+ *
+ * These types define the JWT payload structure and authentication
+ * configuration options for rep portal applications.
+ */
+/**
+ * User type constant - single source of truth for user role values.
+ * Use USER_TYPES.admin instead of "admin" for type-safe comparisons.
+ */
+declare const USER_TYPES: {
+    readonly admin: "admin";
+    readonly rep: "rep";
+    readonly root_admin: "root_admin";
+    readonly customer: "customer";
+};
+/**
+ * Union type of all user types, derived from USER_TYPES constant.
+ * @see deriving-typeof-for-object-keys pattern
+ */
+type UserType = (typeof USER_TYPES)[keyof typeof USER_TYPES];
+/**
+ * Runtime validation for user types.
+ * @param value - The value to check
+ * @returns true if value is a valid UserType
+ */
+declare function isUserType(value: string): value is UserType;
+/**
+ * JWT payload structure from Fluid Commerce authentication.
+ * Contains user identity and role information.
+ */
+interface JWTPayload {
+    /** User ID */
+    id?: number | undefined;
+    /** User email address */
+    email?: string | undefined;
+    /** Full name of the user */
+    full_name?: string | undefined;
+    /** User role type */
+    user_type: UserType;
+    /** Original user type (for impersonation scenarios) */
+    og_user_type?: UserType | undefined;
+    /** Company ID the user belongs to */
+    company_id?: number | undefined;
+    /** Token expiration timestamp (Unix seconds) */
+    exp?: number | undefined;
+    /** Authentication type (e.g., "standard", "impersonation") */
+    auth_type?: string | undefined;
+}
+/**
+ * Configuration options for FluidAuthProvider.
+ * All options have sensible defaults.
+ */
+interface FluidAuthConfig {
+    /**
+     * URL parameter name for the auth token.
+     * @default "fluidUserToken"
+     */
+    tokenKey?: string;
+    /**
+     * Cookie name for storing the auth token.
+     * @default "auth_token"
+     */
+    cookieKey?: string;
+    /**
+     * Cookie max age in seconds.
+     * @default 777600 (9 days)
+     */
+    cookieMaxAge?: number;
+    /**
+     * Grace period in milliseconds to account for clock skew
+     * when checking token expiration.
+     * @default 30000 (30 seconds)
+     */
+    gracePeriodMs?: number;
+    /**
+     * Callback invoked when authentication fails (no valid token).
+     * Use this to redirect to a login page or show an error.
+     */
+    onAuthFailure?: () => void;
+    /**
+     * Enable dev-mode auth bypass.
+     * When true AND running in Vite dev mode (import.meta.env.DEV),
+     * auth will use a synthetic mock user instead of requiring a real JWT.
+     * The mock user allows UI rendering but API calls will fail (token is null).
+     * @default false
+     */
+    devBypass?: boolean;
+    /**
+     * JWKS (JSON Web Key Set) URL for signature verification.
+     * When provided, JWT signatures will be verified against keys
+     * from this endpoint before accepting the token.
+     *
+     * This provides defense-in-depth client-side verification.
+     * Without this, tokens are only decoded (not verified) client-side,
+     * and real verification happens server-side on API calls.
+     *
+     * @example "https://api.fluid.app/.well-known/jwks.json"
+     */
+    jwksUrl?: string;
+}
+/**
+ * Value provided by the FluidAuthContext.
+ * All properties are readonly since context values should not be mutated by consumers.
+ */
+interface FluidAuthContextValue {
+    /** Whether the user is authenticated with a valid token */
+    readonly isAuthenticated: boolean;
+    /** Whether authentication is still being initialized */
+    readonly isLoading: boolean;
+    /** Decoded JWT payload if authenticated, null otherwise */
+    readonly user: JWTPayload | null;
+    /** Raw JWT token string if authenticated, null otherwise */
+    readonly token: string | null;
+    /** Clear authentication state and stored tokens */
+    readonly clearAuth: () => void;
+    /** Authentication error if any occurred during initialization */
+    readonly error: Error | null;
+}
+/**
+ * Result of token validation.
+ * Uses a discriminated union for type-safe handling of valid/invalid states.
+ */
+type TokenValidationResult = {
+    /** Token is valid */
+    isValid: true;
+    /** Decoded JWT payload */
+    payload: JWTPayload;
+    /** No error when valid */
+    error?: undefined;
+} | {
+    /** Token is invalid */
+    isValid: false;
+    /** Decoded JWT payload if parseable but expired */
+    payload?: JWTPayload;
+    /** Error message explaining why validation failed */
+    error: string;
+};
+
+interface FluidAuthProviderProps {
+    /** React children to wrap with auth context */
+    children: ReactNode;
+    /** Auth configuration options */
+    config?: FluidAuthConfig;
+}
+/**
+ * Authentication provider for Fluid rep 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/rep-sdk";
+ *
+ * function App() {
+ *   return (
+ *     <FluidAuthProvider
+ *       config={{
+ *         onAuthFailure: () => {
+ *           window.location.href = "/login";
+ *         },
+ *       }}
+ *     >
+ *       <YourApp />
+ *     </FluidAuthProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function FluidAuthProvider({ children, config, }: FluidAuthProviderProps): react_jsx_runtime.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;
+
+/**
+ * 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;
+}
+
+/**
+ * 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.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_jsx_runtime.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[];
+
+/**
+ * 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;
+
+/**
+ * Query key for profile data
+ */
+declare const PROFILE_QUERY_KEY: readonly ["fluid", "profile"];
+/**
+ * Hook to fetch the rep 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>;
+
+/**
+ * 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;
+
+/**
+ * Result of useFluidTheme hook
+ */
+interface UseFluidThemeResult {
+    /** Currently active theme */
+    currentTheme: Theme | null;
+    /** Switch to a different theme */
+    setTheme: (theme: Theme) => 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: Theme[] }) {
+ *   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;
+
+/**
+ * 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>;
+
+/**
+ * useFluidAuth Hook
+ *
+ * Provides access to authentication state and utilities.
+ * This is the primary hook for interacting with auth in components.
+ */
+
+/**
+ * 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;
+
+/**
+ * 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;
+}
+
+/**
+ * Calendar events hook - stub implementation for SDK
+ * In production, implement this hook to fetch from your API
+ */
+
+/**
+ * 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;
+
+/**
+ * Todos hook - stub implementation for SDK
+ * In production, implement this hook to fetch from your API
+ */
+
+/**
+ * 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;
+
+/**
+ * Activities hook - stub implementation for SDK
+ * In production, implement this hook to fetch from your API
+ */
+
+/**
+ * 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;
+
+/**
+ * Catch ups hook - stub implementation for SDK
+ * In production, implement this hook to fetch from your API
+ */
+
+/**
+ * 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;
+
+/**
+ * MySite hook - stub implementation for SDK
+ * In production, implement this hook to fetch from your API
+ */
+
+/**
+ * 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;
+
+/**
+ * Conversations hooks - stub implementations for SDK
+ * In production, implement these hooks to fetch from your API
+ */
+
+/**
+ * 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;
+
+/**
+ * Contacts hooks - stub implementation for SDK
+ * In production, implement these hooks to fetch from your API
+ */
+
+/**
+ * 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;
+
+/**
+ * Auth Constants for Fluid Rep SDK
+ *
+ * These constants define the default values for authentication
+ * configuration and storage keys.
+ */
+/**
+ * Authentication-related constants with sensible defaults.
+ */
+declare const AUTH_CONSTANTS: {
+    /**
+     * Grace period in milliseconds to account for clock skew
+     * when checking token expiration. Tokens are considered valid
+     * if they expire within this period.
+     */
+    readonly TOKEN_GRACE_PERIOD_MS: number;
+    /**
+     * Default cookie max age in seconds (9 days).
+     * This matches the typical JWT token lifetime from the Fluid API.
+     */
+    readonly COOKIE_MAX_AGE: number;
+};
+/**
+ * Storage keys for auth tokens.
+ */
+declare const STORAGE_KEYS: {
+    /** localStorage key for user token */
+    readonly USER_TOKEN: "fluidUserToken";
+    /** localStorage key for company token (legacy) */
+    readonly COMPANY_TOKEN: "fluidCompanyToken";
+    /** Cookie name for auth token */
+    readonly AUTH_COOKIE: "auth_token";
+};
+/**
+ * Default URL parameter names for token extraction.
+ */
+declare const URL_PARAMS: {
+    /** URL parameter name for user token */
+    readonly USER_TOKEN: "fluidUserToken";
+    /** URL parameter name for company token (legacy) */
+    readonly COMPANY_TOKEN: "fluidCompanyToken";
+};
+
+/**
+ * Token Utilities for Fluid Rep SDK
+ *
+ * Functions for decoding, validating, and checking JWT tokens.
+ */
+
+/**
+ * Decode a JWT token and extract its payload.
+ *
+ * **Security note:** This function does NOT verify the JWT signature.
+ * It only decodes the payload. Any valid JWT structure will be accepted,
+ * regardless of who signed it.
+ *
+ * Client-side token decoding is used for UX purposes only (displaying
+ * user info, role-based UI). The real security boundary is the server-side
+ * API, which verifies the signature on every request.
+ *
+ * For signature verification, use {@link verifyToken} with a JWKS URL.
+ *
+ * @param token - The JWT token string
+ * @returns The decoded JWT payload, or null if decoding fails
+ *
+ * @example
+ * ```ts
+ * const payload = decodeToken(token);
+ * if (payload) {
+ *   console.log(`User: ${payload.email}`);
+ * }
+ * ```
+ */
+declare function decodeToken(token: string): JWTPayload | null;
+/**
+ * Check if a token has expired.
+ * Includes a configurable grace period to account for clock skew.
+ *
+ * @param token - The JWT token string
+ * @param gracePeriodMs - Grace period in milliseconds (default: 30 seconds)
+ * @returns true if the token is expired, false otherwise
+ *
+ * @example
+ * ```ts
+ * if (isTokenExpired(token)) {
+ *   // Token is expired, need to re-authenticate
+ *   clearAuth();
+ * }
+ * ```
+ */
+declare function isTokenExpired(token: string, gracePeriodMs?: number): boolean;
+/**
+ * Validate a JWT token for format and expiration.
+ *
+ * **Security note:** This function checks JWT structure and expiration
+ * but does NOT verify the signature. It is a UX-level check only.
+ * For signature verification, use {@link verifyToken} with a JWKS URL.
+ *
+ * @param token - The JWT token string
+ * @param gracePeriodMs - Grace period for expiration check (default: 30 seconds)
+ * @returns Validation result with status and decoded payload if valid
+ *
+ * @example
+ * ```ts
+ * const result = validateToken(token);
+ * if (result.isValid) {
+ *   console.log(`Welcome, ${result.payload?.full_name}`);
+ * } else {
+ *   console.error(`Auth failed: ${result.error}`);
+ * }
+ * ```
+ */
+declare function validateToken(token: string, gracePeriodMs?: number): TokenValidationResult;
+/**
+ * Type guard to check if a validation result is valid.
+ * Enables TypeScript narrowing of the result type.
+ *
+ * @param result - The validation result to check
+ * @returns true if the token is valid (narrows payload to non-optional)
+ *
+ * @example
+ * ```ts
+ * const result = validateToken(token);
+ * if (isValidToken(result)) {
+ *   // result.payload is guaranteed to be JWTPayload (not undefined)
+ *   console.log(result.payload.email);
+ * }
+ * ```
+ */
+declare function isValidToken(result: TokenValidationResult): result is TokenValidationResult & {
+    isValid: true;
+    payload: JWTPayload;
+};
+/**
+ * Get the expiration time of a token as a Date.
+ *
+ * @param token - The JWT token string
+ * @returns The expiration Date, or null if token has no expiration or is invalid
+ */
+declare function getTokenExpiration(token: string): Date | null;
+/**
+ * Get the time remaining until token expiration in milliseconds.
+ *
+ * @param token - The JWT token string
+ * @returns Milliseconds until expiration, or 0 if expired/invalid, or Infinity if no expiration
+ */
+declare function getTokenTimeRemaining(token: string): number;
+
+/**
+ * Token Storage Utilities for Fluid Rep SDK
+ *
+ * Functions for storing and retrieving auth tokens from
+ * cookies and localStorage.
+ */
+
+/**
+ * Get the stored auth token.
+ * Checks cookie first, then falls back to localStorage.
+ *
+ * @param config - Optional auth config for custom cookie key
+ * @returns The stored token or null if not found
+ *
+ * @example
+ * ```ts
+ * const token = getStoredToken();
+ * if (token) {
+ *   console.log("User is logged in");
+ * }
+ * ```
+ */
+declare function getStoredToken(config?: FluidAuthConfig): string | null;
+/**
+ * Store an auth token in both cookie and localStorage.
+ * Using both provides redundancy and compatibility with different auth flows.
+ *
+ * @param token - The JWT token to store
+ * @param config - Optional auth config for custom storage options
+ *
+ * @example
+ * ```ts
+ * storeToken(newToken);
+ * // Token is now accessible via getStoredToken()
+ * ```
+ */
+declare function storeToken(token: string, config?: FluidAuthConfig): void;
+/**
+ * Clear all stored auth tokens from cookies and localStorage.
+ *
+ * @param config - Optional auth config for custom cookie key
+ *
+ * @example
+ * ```ts
+ * // User logs out
+ * clearTokens();
+ * ```
+ */
+declare function clearTokens(config?: FluidAuthConfig): void;
+/**
+ * Check if any auth token is stored.
+ *
+ * @param config - Optional auth config
+ * @returns true if a token is stored, false otherwise
+ */
+declare function hasStoredToken(config?: FluidAuthConfig): boolean;
+
+/**
+ * URL Token Utilities for Fluid Rep SDK
+ *
+ * Functions for extracting and cleaning auth tokens from URL parameters.
+ * This is the primary way tokens are passed from the parent Fluid Commerce
+ * app to embedded rep portals.
+ *
+ * **Security model**: Tokens in URL parameters are a known tradeoff.
+ * The token is extracted and immediately cleaned from the URL via
+ * `history.replaceState()`. A `Referrer-Policy` meta tag in the
+ * starter template prevents the token from leaking in referrer headers.
+ * See docs/authentication.md for full security analysis.
+ */
+/**
+ * Extract the auth token from the URL query parameters.
+ *
+ * @param tokenKey - The URL parameter name (default: "fluidUserToken")
+ * @returns The token value or null if not present
+ *
+ * @example
+ * ```ts
+ * // URL: https://myportal.com?fluidUserToken=eyJhbG...
+ * const token = extractTokenFromUrl();
+ * // token = "eyJhbG..."
+ * ```
+ */
+declare function extractTokenFromUrl(tokenKey?: string): string | null;
+/**
+ * Extract the company token from the URL query parameters.
+ * This is a legacy parameter that may still be used in some flows.
+ *
+ * @param tokenKey - The URL parameter name (default: "fluidCompanyToken")
+ * @returns The token value or null if not present
+ */
+declare function extractCompanyTokenFromUrl(tokenKey?: string): string | null;
+/**
+ * Remove the auth token from the URL without reloading the page.
+ * This prevents the token from being accidentally shared via URL copy/paste
+ * or appearing in browser history.
+ *
+ * Uses history.replaceState to update the URL cleanly.
+ *
+ * @param tokenKey - The URL parameter name to remove (default: "fluidUserToken")
+ *
+ * @example
+ * ```ts
+ * // Before: https://myportal.com?fluidUserToken=eyJhbG...&page=1
+ * cleanTokenFromUrl();
+ * // After: https://myportal.com?page=1
+ * ```
+ */
+declare function cleanTokenFromUrl(tokenKey?: string): void;
+/**
+ * Check if the URL contains an auth token parameter.
+ *
+ * @param tokenKey - The URL parameter name (default: "fluidUserToken")
+ * @returns true if the URL contains the token parameter
+ */
+declare function hasTokenInUrl(tokenKey?: string): boolean;
+/**
+ * Extract all auth-related tokens from the URL at once.
+ *
+ * @param userTokenKey - The URL parameter name for user token
+ * @param companyTokenKey - The URL parameter name for company token
+ * @returns Object with both token values (or null if not present)
+ */
+declare function extractAllTokensFromUrl(userTokenKey?: string, companyTokenKey?: string): {
+    userToken: string | null;
+    companyToken: string | null;
+};
+
+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_runtime.JSX.Element;
+
+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_runtime.JSX.Element;
+/**
+ * Simple loading spinner component for auth loading state.
+ */
+declare function AuthLoading(): react_jsx_runtime.JSX.Element;
+
+type MessagingScreenProps = ComponentProps<"div"> & {
+    background?: BackgroundValue;
+    textColor?: ColorOptions;
+    accentColor?: ColorOptions;
+    padding?: PaddingOptions;
+    borderRadius?: BorderRadiusOptions;
+    onConversationSelect?: (conversationId: string) => void;
+    onSendMessage?: (conversationId: string, message: string) => void;
+};
+declare function MessagingScreen(_props: MessagingScreenProps): react_jsx_runtime.JSX.Element;
+declare const messagingScreenPropertySchema: WidgetPropertySchema;
+
+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_runtime.JSX.Element;
+declare const contactsScreenPropertySchema: WidgetPropertySchema;
+
+type OrdersScreenProps = ComponentProps<"div"> & {
+    background?: BackgroundValue;
+    textColor?: ColorOptions;
+    accentColor?: ColorOptions;
+    padding?: PaddingOptions;
+    borderRadius?: BorderRadiusOptions;
+};
+declare function OrdersScreen(_props: OrdersScreenProps): react_jsx_runtime.JSX.Element;
+declare const ordersScreenPropertySchema: WidgetPropertySchema;
+
+type CustomersScreenProps = ComponentProps<"div"> & {
+    background?: BackgroundValue;
+    textColor?: ColorOptions;
+    accentColor?: ColorOptions;
+    padding?: PaddingOptions;
+    borderRadius?: BorderRadiusOptions;
+};
+declare function CustomersScreen(_props: CustomersScreenProps): react_jsx_runtime.JSX.Element;
+declare const customersScreenPropertySchema: WidgetPropertySchema;
+
+type ProductsScreenProps = ComponentProps<"div"> & {
+    background?: BackgroundValue;
+    textColor?: ColorOptions;
+    accentColor?: ColorOptions;
+    padding?: PaddingOptions;
+    borderRadius?: BorderRadiusOptions;
+};
+declare function ProductsScreen(_props: ProductsScreenProps): react_jsx_runtime.JSX.Element;
+declare const productsScreenPropertySchema: WidgetPropertySchema;
+
+declare const screenPropertySchemas: {
+    MessagingScreen: () => Promise<_fluid_app_rep_core_registries.WidgetPropertySchema>;
+    ContactsScreen: () => Promise<_fluid_app_rep_core_registries.WidgetPropertySchema>;
+    OrdersScreen: () => Promise<_fluid_app_rep_core_registries.WidgetPropertySchema>;
+    CustomersScreen: () => Promise<_fluid_app_rep_core_registries.WidgetPropertySchema>;
+    ProductsScreen: () => Promise<_fluid_app_rep_core_registries.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";
+};
+
+/**
+ * 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[];
+};
+
+/**
+ * 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;
+
+export { ACTIVITY_SLUGS, AUTH_CONSTANTS, type Activity as ActivityItem, type ActivitySlug, ApiError, AuthError, type AuthErrorProps, AuthLoading, type BaseListParams, CORE_PAGE_IDS, CURRENT_REP_QUERY_KEY, type CalendarEvent, type CatchUp as CatchUpItem, type Contact, type ContactAddress, type ContactStatus, type ContactType, ContactsScreen, type Conversation, type ConversationStatus, type CreateOrderData, CustomersScreen, type DashboardData, type FluidAuthConfig, type FluidAuthContextValue, FluidAuthProvider, type FluidAuthProviderProps, type FluidClient, FluidProvider, type FluidProviderProps, type FluidSDKConfig, FluidThemeProvider, type FluidThemeProviderProps, type JWTPayload, type ListQueryResult, type Message, type MessageType, MessagingScreen, type MySiteData, type Navigation, type NavigationItem, type Order, type OrderLineItem, type OrderListParams, OrdersScreen, PAGE_CATEGORIES, PERMISSIONS_QUERY_KEY, PROFILE_QUERY_KEY, type PageCategory, type PageCategoryId, type PageOverride, type PageReference, type PageTemplate, PageTemplateProvider, PageTemplateRegistry, type PaginationParams, type Participant, type PermissionAction, type Permissions, type Product, type ProductListParams, ProductsScreen, type Profile, type QueryResult, type QueryResultNullable, type Rep, type RequestOptions, RequireAuth, type RequireAuthProps, type ResourcePermissions, STORAGE_KEYS, type SalesData, type SalesDataPoint, type SalesParams, type ScreenDefinition, type Todo as TodoItem, type TokenValidationResult, URL_PARAMS, USER_TYPES, type UpdateRepData, type UseContactResult, type UseContactsParams, type UseContactsResult, type UseConversationMessagesResult, type UseConversationsResult, type UseFluidPermissionsResult, type UseFluidThemeResult, type UseListResourceHook, type UseSingleResourceHook, type UserPermissions, type UserType, type ValueListQueryResult, type WithData, cleanTokenFromUrl, clearTokens, contactsScreenPropertySchema, createFluidClient, customersScreenPropertySchema, decodeToken, extractAllTokensFromUrl, extractCompanyTokenFromUrl, extractTokenFromUrl, getAvailablePageTemplates, getCorePageTemplates, getOptionalPageTemplates, getProperty, getStoredToken, getTokenExpiration, getTokenTimeRemaining, hasData, hasStoredToken, hasTokenInUrl, isActivitySlug, isApiError, isContactStatus, isErrorResult, isIdle, isLoading, isTokenExpired, isUserType, isValidToken, messagingScreenPropertySchema, ordersScreenPropertySchema, productsScreenPropertySchema, resolveNavigationPages, screenPropertySchemas, selectProperty, storeToken, useActivities, useCalendarEvents, useCatchUps, useContact, useContacts, useConversationMessages, useConversations, useCurrentRep, useFluidApi, useFluidAuth, useFluidAuthContext, useFluidContext, useFluidPermissions, useFluidProfile, useFluidTheme, useMySite, usePageTemplates, useResolvedPages, useThemeContext, useTodos, validateNavigationPages, validateToken };