@framed-dev/core 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,3314 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+export { SupabaseClient } from '@supabase/supabase-js';
+
+type LocalizedContent = Record<string, string>;
+type LocalizableString = string | LocalizedContent;
+declare const isLocalizedContent: (value: LocalizableString) => value is LocalizedContent;
+declare const getLocalizedValue: (value: LocalizableString | undefined, language: string, primaryLanguage?: string) => string;
+declare const toLocalizedContent: (value: LocalizableString, primaryLanguage: string) => LocalizedContent;
+declare const ensureLocalizedContent: (value: LocalizableString | undefined, primaryLanguage: string) => LocalizedContent;
+declare const str: (value: LocalizableString | undefined, lang?: string) => string;
+
+/**
+ * i18n utilities - Stub implementations
+ *
+ * These are placeholder functions for internationalization.
+ * In the full SaaS app, this would use react-i18next.
+ * For the widget/SDK, translations should be provided by the host app.
+ */
+type TranslationOptions = {
+    [key: string]: string | number;
+};
+/**
+ * Translation function type
+ * Returns the translation for a key, or the fallback if provided
+ */
+type TFunction = (key: string, fallbackOrOptions?: string | TranslationOptions) => string;
+/**
+ * Stub useTranslation hook
+ *
+ * Returns a simple t function that:
+ * - If second arg is a string, returns it as fallback
+ * - If second arg is an object with interpolation values, returns key with values interpolated
+ * - Otherwise returns the key
+ */
+declare function useTranslation(_namespaces?: string[]): {
+    t: TFunction;
+};
+
+interface Phase2Data {
+    pages: PageDetail[];
+}
+interface PageDetail {
+    id?: string;
+    name: string;
+    layout_type: string;
+    sections: Section[];
+    features: string[];
+}
+interface Section {
+    id?: string;
+    type: string;
+    order: number;
+    custom_name?: string;
+    title: LocalizableString;
+    content: LocalizableString;
+    media: MediaInfo[];
+    ctas: CTAInfo[];
+    additional_content?: AdditionalContentItem[];
+    skip_section: boolean;
+    skip_reason?: string;
+    is_completed?: boolean;
+    is_cms_managed?: boolean;
+    cms_fields?: string[];
+    type_data?: SectionTypeData;
+    ai_layout_hints?: {
+        columns?: number;
+        mediaPosition?: 'left' | 'right' | 'top' | 'bottom' | 'background';
+        style?: 'minimal' | 'bold' | 'elegant' | 'playful';
+    };
+    layout_notes?: string;
+}
+type AdditionalContentType = 'text' | 'image' | 'button' | 'video' | 'heading' | 'list';
+interface AdditionalContentItem {
+    id: string;
+    type: AdditionalContentType;
+    order: number;
+    data: {
+        text?: LocalizableString;
+        media?: MediaInfo;
+        cta?: CTAInfo;
+        heading?: LocalizableString;
+        heading_level?: 'h2' | 'h3' | 'h4';
+        list_items?: LocalizableString | string[];
+        list_style?: 'bullet' | 'numbered';
+    };
+}
+interface SectionTypeData {
+    map_address?: string;
+    map_zoom?: number;
+    form_fields?: string[];
+    form_submit_email?: string;
+    pricing_tiers?: PricingTier[];
+    stats?: Stat[];
+    faqs?: FAQ[];
+}
+interface PricingTier {
+    name: string;
+    price: string;
+    features: string[];
+    highlighted?: boolean;
+}
+interface Stat {
+    number: string;
+    label: string;
+    suffix?: string;
+}
+interface FAQ {
+    question: string;
+    answer: string;
+}
+interface MediaInfo {
+    type: 'image' | 'video' | 'illustration' | 'icon' | 'none';
+    description: LocalizableString;
+    alt?: string;
+    url: string | null;
+    uploaded_file?: {
+        name: string;
+        size: number;
+        type: string;
+        path: string;
+    };
+}
+interface CTAInfo {
+    text: LocalizableString;
+    action: string;
+    target: string;
+}
+
+type PlanTier = 'free' | 'pro' | 'team';
+type AuthMode = 'dev' | 'local' | 'magic_link' | 'framed_login';
+type TaskStatus = 'open' | 'in_progress' | 'done' | 'rejected';
+type TaskType = 'text_change' | 'bug_report' | 'style_change' | 'feature_request' | 'content_update' | 'general_feedback';
+interface FramedConfig {
+    projectId: string;
+    mode: 'local' | 'sync';
+    auth: AuthConfig;
+    ai?: AIConfig;
+    sync?: SyncConfig;
+    widget?: WidgetConfig;
+    features?: Partial<WidgetFeatures>;
+}
+interface AuthConfig {
+    mode: AuthMode;
+    loginRoute?: string;
+    allowedEmails?: string[];
+}
+interface AIConfig {
+    provider: 'openrouter' | 'anthropic';
+    apiKey: string;
+    model?: string;
+}
+interface SyncConfig {
+    apiKey: string;
+    supabaseUrl: string;
+}
+interface WidgetConfig {
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    theme?: 'light' | 'dark' | 'auto';
+    hotkey?: string;
+}
+interface WidgetFeatures {
+    elementSelect: boolean;
+    textEdit: boolean;
+    annotate: boolean;
+    screenshot: boolean;
+    regionSelect: boolean;
+    screenRecording: boolean;
+    voiceInput: boolean;
+    mobilePreview: boolean;
+    feedbackDrawer: boolean;
+    multiplayer: boolean;
+    presence: boolean;
+    assignments: boolean;
+    mentions: boolean;
+    activityFeed: boolean;
+    teamRoles: boolean;
+}
+interface Session {
+    id: string;
+    user: {
+        id: string;
+        name: string;
+        email?: string;
+    };
+    permissions: {
+        canSubmitFeedback: boolean;
+        canViewTasks: boolean;
+        canEditTasks: boolean;
+    };
+    limits: UsageLimits;
+    expiresAt: string;
+}
+interface UsageLimits {
+    feedbackPerMonth: number;
+    feedbackUsed: number;
+    aiParsesPerMonth: number;
+    aiParsesUsed: number;
+    projects: number;
+    reviewersPerProject: number;
+    historyRetentionDays: number;
+}
+interface Task {
+    id: string;
+    type: TaskType;
+    status: TaskStatus;
+    element?: ElementInfo;
+    page: PageInfo;
+    feedback: FeedbackInfo;
+    task: TaskInfo;
+    attachments?: Attachment[];
+    assignment?: Assignment;
+    mentions?: Mention[];
+    comments?: Comment[];
+    meta: TaskMeta;
+}
+interface ElementInfo {
+    selector: string;
+    xpath: string;
+    tagName: string;
+    textContent?: string;
+    rect: DOMRect;
+}
+interface PageInfo {
+    url: string;
+    path: string;
+    title: string;
+}
+interface FeedbackInfo {
+    text: string;
+    originalText?: string;
+    voiceTranscript?: string;
+}
+interface TaskInfo {
+    title: string;
+    description: string;
+    suggestedChanges?: string;
+}
+interface Attachment {
+    id: string;
+    type: 'screenshot' | 'recording' | 'annotation';
+    url: string;
+    thumbnailUrl?: string;
+    mimeType: string;
+    size: number;
+}
+interface Assignment {
+    userId: string;
+    userName: string;
+    assignedAt: string;
+}
+interface Mention {
+    userId: string;
+    userName: string;
+    position: {
+        start: number;
+        end: number;
+    };
+}
+interface TaskComment {
+    id: string;
+    userId: string;
+    userName: string;
+    text: string;
+    createdAt: string;
+}
+/** @deprecated Use TaskComment instead */
+type Comment = TaskComment;
+interface TaskMeta {
+    createdAt: string;
+    updatedAt: string;
+    createdBy: string;
+    projectId: string;
+}
+interface WidgetDataLayer {
+    getSession(): Promise<Session | null>;
+    loadTasks(page?: string): Promise<Task[]>;
+    saveTask(task: Task): Promise<void>;
+    updateTask(id: string, updates: Partial<Task>): Promise<void>;
+    uploadFile(file: File): Promise<{
+        url: string;
+        path: string;
+    }>;
+    checkLimits(): Promise<LimitStatus>;
+    sync?(): Promise<SyncResult>;
+}
+interface LimitStatus {
+    canSubmitFeedback: boolean;
+    feedbackRemaining: number;
+    canUseAI: boolean;
+    aiParsesRemaining: number;
+}
+interface SyncResult {
+    success: boolean;
+    syncedTasks: number;
+    errors?: string[];
+}
+type AnnotationMode = 'select' | 'text-edit' | 'highlight' | 'underline' | 'strikethrough' | 'circle' | 'bracket' | 'draw' | null;
+type ViewportMode = 'desktop' | 'tablet' | 'mobile';
+interface Position {
+    x: number;
+    y: number;
+}
+interface AnnotationData {
+    type: string;
+    color: string;
+}
+interface PendingAttachment {
+    id: string;
+    file: File;
+    type: string;
+    previewUrl: string | null;
+}
+interface ElementHierarchy {
+    tagName: string;
+    id?: string;
+    className?: string;
+}
+interface FeedbackComment {
+    id: string;
+    content: string;
+    contentHtml?: string;
+    author: string;
+    createdAt: string;
+    resolved: boolean;
+    pageUrl?: string;
+    pageTitle?: string;
+    position?: Position;
+    selector?: string;
+    elementText?: string;
+    elementType?: string;
+    elementId?: string;
+    elementClassName?: string;
+    parentHierarchy?: ElementHierarchy[];
+    attachments?: {
+        url: string;
+        type: string;
+        fileName: string;
+    }[];
+    annotation?: AnnotationData;
+    textEdit?: {
+        originalText: string;
+        newText: string;
+    };
+    viewport?: {
+        width: number;
+        height: number;
+        type: ViewportMode;
+    };
+}
+interface WidgetUIState {
+    feedbackPanelOpen: boolean;
+    quickInputOpen: boolean;
+    chatModalOpen: boolean;
+    annotationMode: AnnotationMode;
+    annotationColor: string;
+    selectedElement: Element | null;
+    hoveredElement: Element | null;
+    originalText: string;
+    editedText: string;
+    isDrawing: boolean;
+    drawingPaths: {
+        points: Position[];
+        color: string;
+    }[];
+    comments: FeedbackComment[];
+    showResolved: boolean;
+    isCapturing: boolean;
+    isRegionSelectMode: boolean;
+    isRecording: boolean;
+    pendingAttachments: PendingAttachment[];
+    richTextMode: boolean;
+    viewportMode: ViewportMode;
+    currentPageUrl: string;
+}
+/**
+ * SDK Configuration for dual-client architecture.
+ * - User's Supabase → Data storage (projects, tasks, files)
+ * - Framed API → AI/premium features
+ */
+interface SDKConfig {
+    supabaseUrl: string;
+    supabaseKey: string;
+    framedApiKey?: string;
+    projectId?: string;
+    theme?: 'light' | 'dark';
+}
+/**
+ * Result wrapper for AI-enhanced operations.
+ * Indicates whether AI was used or fallback occurred.
+ */
+interface AIFeatureResult<T> {
+    data: T;
+    wasEnhanced: boolean;
+    fallbackReason?: string;
+}
+/**
+ * Generic upload result for file operations.
+ */
+interface UploadResult {
+    url: string;
+    name: string;
+    type?: string;
+    size?: number;
+    format?: string;
+}
+/**
+ * Result from AI translation service.
+ */
+interface TranslationResult {
+    translations: Record<string, string>;
+    errors: Record<string, string>;
+}
+/**
+ * Callback interface for wizard components.
+ * These are implemented by the SDK using the dual-client architecture.
+ */
+interface WizardCallbacks {
+    onUploadFile: (file: File) => Promise<UploadResult>;
+    onUploadFont: (file: File) => Promise<UploadResult>;
+    onLogoUpload: (file: File) => Promise<void>;
+    onTranslateAll: (value: Record<string, string>, primaryLanguage: string, targetLanguages: string[]) => Promise<TranslationResult>;
+}
+
+/**
+ * Section completion status for Phase 2 navigation.
+ */
+type SectionStatus = 'empty' | 'in_progress' | 'completed' | 'skipped';
+/**
+ * Global subsection types for Phase 2 navigation.
+ */
+type GlobalsSubType = 'navigation' | 'footer' | 'cta' | 'sitemap' | 'media' | 'review';
+/**
+ * Phase 2 navigation state.
+ */
+interface Phase2NavigationState {
+    activePageIndex: number;
+    activeSectionIndex: number;
+    activeGlobalsType: GlobalsSubType | null;
+    isGlobalsExpanded: boolean;
+    totalSections: number;
+}
+/**
+ * Phase 2 navigation actions.
+ */
+interface Phase2NavigationActions {
+    setActivePageIndex: (index: number) => void;
+    setActiveSectionIndex: (index: number) => void;
+    setActiveGlobalsType: (type: GlobalsSubType | null) => void;
+    setIsGlobalsExpanded: (expanded: boolean) => void;
+    goToNextSection: () => void;
+    goToPreviousSection: () => void;
+    goToPage: (pageIndex: number, sectionIndex?: number) => void;
+    goToGlobals: (type: GlobalsSubType) => void;
+}
+/**
+ * Get page completion status based on sections.
+ */
+declare const getPageStatus: (page: PageDetail) => SectionStatus;
+/**
+ * Get section completion status.
+ */
+declare const getSectionStatus: (section: Section) => SectionStatus;
+
+declare const PLAN_LIMITS: Record<PlanTier, UsageLimits>;
+declare const FEATURE_DEFAULTS: Record<PlanTier, WidgetFeatures>;
+declare function canSubmitFeedback(limits: UsageLimits): boolean;
+declare function canUseAI(limits: UsageLimits): boolean;
+declare function getFeaturesForTier(tier: PlanTier): WidgetFeatures;
+declare function mergeFeatures(tier: PlanTier, overrides?: Partial<WidgetFeatures>): WidgetFeatures;
+
+/**
+ * Core modules in the Framed application
+ * - build: Discovery (Phase 1), Project Details (Phase 2), Overview & Export (Phase 3)
+ * - review: Feedback & Review (Phase 4)
+ * - manage: Manage & Maintain (Phase 5)
+ */
+type ModuleType = 'build' | 'review' | 'manage';
+/**
+ * Mapping of modules to their constituent phases
+ */
+declare const MODULE_PHASES: Record<ModuleType, number[]>;
+/**
+ * Mapping of phases to their parent module
+ */
+declare const PHASE_TO_MODULE: Record<number, ModuleType>;
+/**
+ * Module display information
+ */
+interface ModuleInfo {
+    id: ModuleType;
+    name: string;
+    shortName: string;
+    description: string;
+    phases: number[];
+    icon: string;
+}
+declare const MODULES: ModuleInfo[];
+/**
+ * Module limits per agency (null = unlimited)
+ */
+interface ModuleLimits {
+    build: number | null;
+    review: number | null;
+    manage: number | null;
+}
+/**
+ * Module usage statistics for an agency
+ */
+interface ModuleUsageStats {
+    module: ModuleType;
+    used: number;
+    limit: number | null;
+    remaining: number | null;
+    percentage: number | null;
+}
+/**
+ * Plan configuration with module limits
+ */
+interface PlanConfiguration {
+    id: string;
+    plan_type: PlanType;
+    display_name: string;
+    description: string;
+    build_limit: number | null;
+    review_limit: number | null;
+    manage_limit: number | null;
+    total_project_limit: number | null;
+    included_features: string[];
+    price_monthly_cents?: number;
+    price_yearly_cents?: number;
+    currency: string;
+    is_active: boolean;
+    sort_order: number;
+}
+type PlanType = 'oneoff' | 'silver' | 'gold';
+type SubscriptionStatus = 'active' | 'expired' | 'cancelled' | 'trialing';
+interface ProjectLike {
+    project_type?: 'standard' | 'review_only' | 'manage_only';
+    enabled_modules?: ModuleType[] | null;
+    visible_modules?: ModuleType[] | null;
+    disabled_phases?: number[];
+}
+interface AgencyLike {
+    plan_type?: PlanType;
+    module_limits?: ModuleLimits;
+}
+/**
+ * Get default enabled modules based on project type
+ */
+declare const getDefaultModules: (project: ProjectLike) => ModuleType[];
+/**
+ * Check if a module is enabled for a project
+ * Enabled modules have the feature available (can be accessed)
+ */
+declare const isModuleEnabled: (project: ProjectLike | null, module: ModuleType) => boolean;
+/**
+ * Check if a module is visible in the UI for a project
+ * Visible modules show in navigation (enabled + not hidden)
+ */
+declare const isModuleVisible: (project: ProjectLike | null, module: ModuleType) => boolean;
+/**
+ * Check if a specific phase is accessible based on module configuration
+ */
+declare const isPhaseAccessible: (project: ProjectLike | null, phase: number) => boolean;
+/**
+ * Check if a specific phase should be shown in navigation
+ * Combines module visibility with legacy disabled_phases support
+ */
+declare const isPhaseVisible: (project: ProjectLike | null, phase: number) => boolean;
+/**
+ * Get the phases that are visible for a project (shown in navigation)
+ */
+declare const getVisiblePhases: (project: ProjectLike | null) => number[];
+/**
+ * Get the phases that are accessible for a project (can be navigated to, even if hidden from nav)
+ */
+declare const getAccessiblePhases: (project: ProjectLike | null) => number[];
+/**
+ * Get the first accessible phase for a project
+ * Uses accessible phases (not just visible) so hidden phases can still be accessed
+ */
+declare const getFirstAccessiblePhase: (project: ProjectLike | null) => number;
+/**
+ * Get the first visible phase for a project
+ * Used for dashboard navigation - respects hidden phases (e.g., completed review phase)
+ */
+declare const getFirstVisiblePhase: (project: ProjectLike | null) => number;
+/**
+ * Get module limits for an agency based on plan type or explicit limits
+ */
+declare const getModuleLimits: (agency: AgencyLike | null) => ModuleLimits;
+/**
+ * Check if a module limit is unlimited
+ */
+declare const isModuleUnlimited: (agency: AgencyLike | null, module: ModuleType) => boolean;
+/**
+ * Get display name for a module
+ */
+declare const getModuleDisplayName: (module: ModuleType) => string;
+/**
+ * Get module description
+ */
+declare const getModuleDescription: (module: ModuleType) => string;
+/**
+ * Get phases included in a module as a readable string
+ */
+declare const getModulePhasesLabel: (module: ModuleType) => string;
+
+/**
+ * Project categories - defines the type of digital product being specified
+ * @default 'website' for backwards compatibility
+ */
+type ProjectCategory = 'website' | 'saas' | 'mobile_app' | 'ecommerce' | 'api_backend' | 'custom';
+type MobilePlatform = 'ios' | 'android' | 'cross_platform' | 'pwa';
+type SaasCategory = 'b2b' | 'b2c' | 'internal' | 'marketplace';
+type ApiStyle = 'rest' | 'graphql' | 'grpc' | 'websocket';
+/**
+ * Screen types - universal term for pages/screens/endpoints across project types
+ */
+type ScreenType = 'page' | 'screen' | 'endpoint' | 'flow' | 'dashboard' | 'modal' | 'email';
+/**
+ * Universal screen definition - replaces "pages" concept for multi-type support
+ */
+interface ScreenDefinition {
+    id: string;
+    name: string;
+    type: ScreenType;
+    order: number;
+    description?: LocalizableString;
+    features: string[];
+    ai_generated?: boolean;
+    template_source?: string;
+    website_page?: WebsitePageConfig;
+    app_screen?: AppScreenConfig;
+    api_endpoint?: ApiEndpointConfig;
+    user_flow?: UserFlowConfig;
+}
+interface WebsitePageConfig {
+    is_landing_page?: boolean;
+    seo_priority?: 'high' | 'medium' | 'low';
+    content_type?: 'static' | 'dynamic' | 'cms_managed';
+}
+interface AppScreenConfig {
+    navigation_type: 'stack' | 'tab' | 'drawer' | 'modal';
+    has_header: boolean;
+    has_bottom_nav: boolean;
+    scroll_behavior: 'scroll' | 'fixed' | 'paginated';
+    gesture_interactions: string[];
+}
+interface ApiEndpointConfig {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    authentication_required: boolean;
+    rate_limited: boolean;
+    request_body?: DataModelReference;
+    response_body?: DataModelReference;
+}
+interface UserFlowConfig {
+    steps: FlowStep[];
+    entry_points: string[];
+    exit_points: string[];
+    branching_logic?: BranchingRule[];
+}
+interface FlowStep {
+    id: string;
+    name: string;
+    screen_id?: string;
+    description?: string;
+    order: number;
+}
+interface BranchingRule {
+    condition: string;
+    target_step_id: string;
+}
+interface DataModelReference {
+    model_name: string;
+    fields?: string[];
+}
+/**
+ * SaaS application specific details
+ */
+interface SaasDetails {
+    category: SaasCategory;
+    has_user_accounts: boolean;
+    user_types: string[];
+    subscription_model: 'free' | 'freemium' | 'paid' | 'enterprise' | null;
+    key_features: string[];
+    integrations_needed: string[];
+    data_sensitivity: 'public' | 'private' | 'sensitive' | 'regulated';
+    estimated_users: 'small' | 'medium' | 'large' | 'enterprise';
+    real_time_features?: boolean;
+    collaboration_features?: boolean;
+}
+/**
+ * Mobile app specific details
+ */
+interface MobileAppDetails {
+    platforms: MobilePlatform[];
+    distribution: 'app_store' | 'enterprise' | 'sideload';
+    offline_support: boolean;
+    push_notifications: boolean;
+    native_features: string[];
+    monetization: 'free' | 'paid' | 'freemium' | 'ads' | 'subscription';
+    minimum_os_versions?: {
+        ios?: string;
+        android?: string;
+    };
+    tablet_support?: boolean;
+}
+/**
+ * API/Backend specific details
+ */
+interface ApiBackendDetails {
+    api_style: ApiStyle;
+    authentication: 'none' | 'api_key' | 'oauth' | 'jwt' | 'custom';
+    consumers: string[];
+    estimated_requests: 'low' | 'medium' | 'high' | 'enterprise';
+    data_models: DataModelDefinition[];
+    versioning_strategy?: 'url' | 'header' | 'query_param';
+    rate_limiting?: boolean;
+    webhooks?: boolean;
+}
+interface DataModelDefinition {
+    name: string;
+    description?: string;
+    fields: DataFieldDefinition[];
+    relationships?: DataRelationship[];
+}
+interface DataFieldDefinition {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'date' | 'array' | 'object' | 'file';
+    required: boolean;
+    description?: string;
+}
+interface DataRelationship {
+    target_model: string;
+    type: 'one_to_one' | 'one_to_many' | 'many_to_many';
+    field_name: string;
+}
+/**
+ * Enhanced e-commerce details (upgraded from existing ecommerce_details)
+ */
+interface EnhancedEcommerceDetails {
+    product_types: string;
+    payment_methods: string[];
+    shipping_info: string;
+    has_existing_products: boolean;
+    inventory_management: boolean;
+    multi_vendor: boolean;
+    subscription_products: boolean;
+    digital_products: boolean;
+    international_shipping: boolean;
+    tax_handling: 'simple' | 'complex' | 'automated';
+    product_variants: boolean;
+    reviews_enabled: boolean;
+    wishlist_enabled: boolean;
+}
+type QuestionType = 'text' | 'textarea' | 'select' | 'multiselect' | 'boolean' | 'scale' | 'conditional';
+type QuestionCategory = 'core' | 'feature' | 'technical' | 'business' | 'ux' | 'integration';
+/**
+ * AI-generated question for dynamic discovery
+ */
+interface AIQuestion {
+    id: string;
+    question: LocalizableString;
+    type: QuestionType;
+    options?: QuestionOption[];
+    validation?: ValidationRule;
+    depends_on?: DependencyRule;
+    ai_generated: boolean;
+    priority: number;
+    category: QuestionCategory;
+    help_text?: LocalizableString;
+    placeholder?: LocalizableString;
+}
+interface QuestionOption {
+    value: string;
+    label: LocalizableString;
+    description?: LocalizableString;
+    icon?: string;
+}
+interface ValidationRule {
+    required?: boolean;
+    min_length?: number;
+    max_length?: number;
+    pattern?: string;
+    custom_message?: LocalizableString;
+}
+interface DependencyRule {
+    question_id: string;
+    operator: 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'exists';
+    value: unknown;
+}
+/**
+ * AI conversation context for dynamic questioning
+ */
+interface SuggestedPage {
+    id: string;
+    name: string;
+    reason: string;
+}
+interface AIConversation {
+    project_idea: string;
+    inferred_category?: ProjectCategory;
+    confidence_score?: number;
+    detected_features?: string[];
+    suggested_pages?: SuggestedPage[];
+    follow_up_questions: AIQuestion[];
+    answers: Record<string, unknown>;
+    conversation_history?: AIConversationTurn[];
+    analyzed_context?: {
+        url_insights?: string;
+        document_insights?: string;
+    };
+}
+/**
+ * Project context for AI analysis
+ * Allows users to provide additional context like existing websites, briefs, or documents
+ */
+interface ProjectContextFile {
+    name: string;
+    url: string;
+    type: 'pdf' | 'doc' | 'image' | 'text';
+    size?: number;
+    extracted_text?: string;
+}
+interface ProjectContext {
+    existing_url?: string;
+    context_text?: string;
+    context_files?: ProjectContextFile[];
+}
+interface AIConversationTurn {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+    timestamp: string;
+}
+interface GlobalElements {
+    navigation: {
+        logo_position: 'left' | 'center' | 'right';
+        menu_style: 'horizontal' | 'hamburger' | 'sidebar';
+        menu_items: LocalizableString;
+        cta_button?: {
+            text: LocalizableString;
+            action: string;
+            style: 'primary' | 'secondary' | 'outline';
+        };
+    };
+    footer: {
+        columns: number;
+        content: LocalizableString;
+        show_social: boolean;
+        social_links?: string;
+        copyright: LocalizableString;
+    };
+    global_cta: {
+        primary_cta: LocalizableString;
+        secondary_cta?: LocalizableString;
+    };
+}
+interface PageContent {
+    description: LocalizableString;
+    features: string[];
+}
+interface Reference {
+    url: string;
+    notes: string;
+}
+/**
+ * AI-generated project overview shown between Phase 1 and Phase 2
+ * Allows users to review and edit AI's understanding before proceeding
+ */
+interface ProjectOverview {
+    /** High-level project summary (2-3 sentences) */
+    project_summary: string;
+    /** Key features extracted from discovery (3-5 items) */
+    key_features: string[];
+    /** Target audience summary */
+    target_audience_summary: string;
+    /** Design direction based on style keywords */
+    design_direction: string;
+    /** Purpose of each page/screen */
+    recommended_pages: Array<{
+        name: string;
+        purpose: string;
+    }>;
+    /** When the overview was last edited by user */
+    edited_at?: string;
+    /** User's choice for content approach */
+    content_approach?: 'manual' | 'ai_generated' | 'scrape_existing';
+    /** When the overview was generated */
+    generated_at?: string;
+    /** Imported content from existing website (when content_approach is 'scrape_existing') */
+    imported_content?: ImportedContentData;
+}
+/**
+ * Data structure for content imported from an existing website
+ */
+interface ImportedContentData {
+    /** Source URL that was crawled */
+    source_url: string;
+    /** When the content was imported */
+    imported_at: string;
+    /** Crawled pages with their content */
+    pages: ImportedPageData[];
+    /** Downloaded images */
+    images: ImportedImageData[];
+}
+interface ImportedPageData {
+    /** Page name/title */
+    name: string;
+    /** Original URL */
+    url: string;
+    /** Content sections */
+    sections: ImportedSectionData[];
+}
+interface ImportedSectionData {
+    id: string;
+    name: string;
+    order: number;
+    blocks: ImportedBlockData[];
+}
+interface ImportedBlockData {
+    id: string;
+    type: 'heading' | 'text' | 'list' | 'button';
+    tagName: string;
+    content: string;
+    order: number;
+    level?: number;
+    items?: string[];
+    href?: string;
+}
+interface ImportedImageData {
+    /** Original URL from source site */
+    originalUrl: string;
+    /** Stored URL in our bucket */
+    storedUrl: string;
+    /** Alt text */
+    alt?: string;
+    /** Source page URL */
+    pageUrl: string;
+}
+/**
+ * Phase 1 Data - Discovery phase
+ */
+interface Phase1Data {
+    /**
+     * Project category - determines the type of digital product
+     * @default 'website' for backwards compatibility
+     */
+    project_category?: ProjectCategory;
+    /**
+     * AI conversation context for dynamic questioning
+     */
+    ai_conversation?: AIConversation;
+    /**
+     * Universal screens array - replaces pages for multi-type support
+     * For websites, these map to pages; for apps, to screens; for APIs, to endpoints
+     */
+    screens?: ScreenDefinition[];
+    /**
+     * Category-specific details
+     */
+    saas_details?: SaasDetails;
+    mobile_details?: MobileAppDetails;
+    api_details?: ApiBackendDetails;
+    enhanced_ecommerce_details?: EnhancedEcommerceDetails;
+    /**
+     * Project context for AI analysis
+     * Allows users to provide existing website URLs, briefs, or documents
+     */
+    project_context?: ProjectContext;
+    business_name: string;
+    industry: string;
+    goal: LocalizableString;
+    audience: LocalizableString;
+    primary_device: 'mobile' | 'desktop' | 'both';
+    /** @deprecated Use project_category === 'ecommerce' and enhanced_ecommerce_details instead */
+    is_ecommerce: boolean;
+    /** @deprecated Use enhanced_ecommerce_details instead */
+    ecommerce_details?: {
+        product_types: string;
+        payment_methods: string[];
+        shipping_info: string;
+        has_existing_products: boolean;
+    };
+    /** @deprecated Use screens array instead */
+    pages: string[];
+    /** @deprecated Use screens array instead */
+    custom_pages: string[];
+    page_names: Record<string, string>;
+    page_content: Record<string, PageContent>;
+    legal_content_preference: 'has_content' | 'needs_creation' | 'not_sure';
+    has_logo: boolean;
+    logo_url: string | null;
+    colors: {
+        primary: string | null;
+        secondary: string | null;
+        accent: string | null;
+        no_idea: boolean;
+    };
+    font: {
+        primary: string | null;
+        secondary: string | null;
+        custom_fonts: string[];
+        custom_font_files: {
+            name: string;
+            url: string;
+            format: 'woff' | 'woff2' | 'ttf' | 'otf';
+        }[];
+        no_idea: boolean;
+    };
+    style_keywords: string[];
+    references: Reference[];
+    globals?: GlobalElements;
+    functionality?: {
+        cms: {
+            type: 'none' | 'custom' | 'existing' | 'headless';
+            existing_cms?: string;
+            cms_features?: string[];
+        };
+        languages: {
+            is_multilingual: boolean;
+            primary_language: string;
+            additional_languages: string[];
+            translation_method?: 'manual' | 'automated' | 'hybrid';
+        };
+        integrations: {
+            analytics: string[];
+            marketing: string[];
+            social: string[];
+            payment: string[];
+            other: string[];
+        };
+        authentication: {
+            needs_auth: boolean;
+            auth_type?: 'social' | 'email' | 'sso' | 'custom';
+            user_roles?: string[];
+            features?: string[];
+        };
+        technical: {
+            hosting_preference?: 'managed' | 'self-hosted' | 'no_preference';
+            performance_priority: 'speed' | 'features' | 'balanced';
+            accessibility_level: 'basic' | 'wcag_aa' | 'wcag_aaa';
+            seo_requirements?: string[];
+        };
+        additional: string[];
+    };
+    homepage_layout?: string;
+    /**
+     * Cached AI-enhanced prompt data to avoid re-generating
+     */
+    enhanced_prompts?: {
+        enhanced_prompt?: string;
+        planning_section?: string;
+        project_instructions_md?: string;
+        generated_at?: string;
+    };
+    /**
+     * AI-generated project overview for Phase 1 → Phase 2 transition
+     * Stores the overview summary and user's content approach choice
+     */
+    overview?: ProjectOverview;
+}
+
+interface Phase3Data {
+    generated_prompt: string;
+    json_export: Record<string, unknown>;
+    submitted_at?: string;
+    submitted_by?: string;
+}
+/**
+ * Supported AI tools for export generation
+ */
+type AIToolType = 'bolt' | 'lovable' | 'v0' | 'cursor' | 'claude' | '10web' | 'windsurf' | 'notion';
+/**
+ * Export format options
+ */
+type ExportFormat = 'long_prompt' | 'short_prompt' | 'markdown_file';
+/**
+ * AI tool configuration with metadata
+ */
+interface AIToolConfig {
+    id: AIToolType;
+    name: string;
+    description: string;
+    icon?: string;
+    supportedFormats: ExportFormat[];
+    promptStyle?: 'detailed' | 'concise' | 'conversational';
+    maxTokens?: number;
+}
+/**
+ * Status of a build spec todo item
+ */
+type BuildSpecItemStatus = 'pending' | 'in_progress' | 'completed' | 'skipped';
+/**
+ * A single todo item in the build spec
+ */
+interface BuildSpecItem {
+    id: string;
+    title: string;
+    description?: string;
+    status: BuildSpecItemStatus;
+    order: number;
+    pageName?: string;
+    sectionId?: string;
+    content?: {
+        text?: string;
+        images?: {
+            url: string;
+            alt?: string;
+            caption?: string;
+        }[];
+    };
+    createdAt: string;
+    createdBy?: string;
+    updatedAt?: string;
+    updatedBy?: string;
+    completedAt?: string;
+    completedBy?: string;
+    notes?: string;
+}
+/**
+ * A section grouping related build spec items
+ */
+interface BuildSpecSection {
+    id: string;
+    title: string;
+    description?: string;
+    order: number;
+    type: 'overview' | 'page' | 'global' | 'technical';
+    pageName?: string;
+    items: BuildSpecItem[];
+    collapsed?: boolean;
+}
+/**
+ * Generated export for an AI tool
+ */
+interface BuildSpecExport {
+    id: string;
+    toolType: AIToolType;
+    format: ExportFormat;
+    content: string;
+    generatedAt: string;
+    generatedBy: string;
+    fileName?: string;
+    fileSize?: number;
+}
+/**
+ * Build spec phase data stored in project.data.buildSpec
+ */
+interface BuildSpecData {
+    sections: BuildSpecSection[];
+    autoGeneratedAt?: string;
+    autoGeneratedFrom?: 'phase1' | 'phase2' | 'both';
+    lastManualEditAt?: string;
+    lastManualEditBy?: string;
+    exports?: BuildSpecExport[];
+    lastExportAt?: string;
+    preferredTool?: AIToolType;
+    editorContent?: string;
+    totalItems?: number;
+    completedItems?: number;
+}
+
+interface FeedbackRound {
+    id: string;
+    round_number: number;
+    started_at: string;
+    started_by: string;
+    started_by_name: string;
+    ended_at?: string;
+    ended_by?: string;
+    ended_by_name?: string;
+    status: 'active' | 'feedback_complete' | 'closed';
+    feedback_completed_at?: string;
+    feedback_completed_by?: string;
+    feedback_completed_by_name?: string;
+    summary?: FeedbackRoundSummary;
+    screenshot_version?: number;
+}
+interface FeedbackRoundSummary {
+    total_items: number;
+    resolved_in_round: number;
+    carried_over: number;
+    unable_to_resolve: number;
+    new_items_added: number;
+}
+interface ResolutionImportResult {
+    imported_at: string;
+    imported_by: string;
+    imported_by_name: string;
+    round_number: number;
+    matched_items: number;
+    resolved_count: number;
+    unable_count: number;
+    unmatched_ids: string[];
+    unmatched_notes: string;
+}
+type ResolutionStatus = 'resolved' | 'unable_to_resolve' | 'needs_clarification';
+interface ParsedResolutionItem {
+    feedback_id: string;
+    status: ResolutionStatus;
+    description: string;
+    question?: string;
+}
+type ImageStatus = 'pending' | 'approved' | 'changes_requested';
+interface PageImage {
+    id: string;
+    page_name: string;
+    image_url: string;
+    alt_text?: string;
+    detected_from: 'crawl' | 'manual' | 'upload';
+    dimensions?: {
+        width: number;
+        height: number;
+    };
+    file_size?: number;
+    status: ImageStatus;
+    approved_by?: string;
+    approved_by_name?: string;
+    approved_at?: string;
+    suggested_replacement?: {
+        url: string;
+        uploaded_by: string;
+        uploaded_by_name: string;
+        uploaded_at: string;
+        reason?: string;
+    };
+    comments?: ImageComment[];
+    created_at: string;
+    updated_at: string;
+}
+interface ImageComment {
+    id: string;
+    user_id: string;
+    user_name: string;
+    user_role: UserRole;
+    comment: string;
+    created_at: string;
+    edited_at?: string;
+}
+type SectionSuggestionStatus = 'pending' | 'approved' | 'rejected';
+interface SectionSuggestion {
+    id: string;
+    page_name: string;
+    type: string;
+    title: LocalizableString;
+    content: LocalizableString;
+    media_type: 'image' | 'video' | 'illustration' | 'icon' | 'none';
+    media_description?: LocalizableString;
+    notes?: string;
+    suggested_by: string;
+    suggested_by_name: string;
+    suggested_by_role: UserRole;
+    suggested_at: string;
+    status: SectionSuggestionStatus;
+    reviewed_by?: string;
+    reviewed_by_name?: string;
+    reviewed_at?: string;
+    review_notes?: string;
+}
+interface ContentBlock {
+    id: string;
+    type: 'heading' | 'text' | 'list';
+    tagName: string;
+    originalContent: string;
+    currentContent: string;
+    order: number;
+    level?: number;
+    items?: string[];
+    currentItems?: string[];
+}
+interface ContentSection {
+    id: string;
+    name: string;
+    order: number;
+    blocks: ContentBlock[];
+    collapsed?: boolean;
+}
+interface TextEdit {
+    id: string;
+    blockId: string;
+    sectionId: string;
+    previousContent: string;
+    newContent: string;
+    editedAt: string;
+    editedBy: string;
+    editedByName: string;
+    editedByRole: UserRole;
+    editType: 'modify' | 'restore';
+    comment?: string;
+    resolved?: boolean;
+    resolvedAt?: string;
+    resolvedBy?: string;
+    resolvedByName?: string;
+}
+interface LanguageContent {
+    language: string;
+    pageTitle?: string;
+    sections: ContentSection[];
+    crawledAt: string;
+    crawledBy: string;
+    editHistory: TextEdit[];
+}
+interface PageTextContent {
+    pageUrl: string;
+    languages: Record<string, LanguageContent>;
+    primaryLanguage: string;
+    version: number;
+}
+interface CrawledTextElement {
+    id: string;
+    selector: string;
+    tagName: string;
+    elementType: CrawledElementType;
+    originalText: string;
+    currentText: string;
+    order: number;
+    parentSelector?: string;
+}
+type CrawledElementType = 'heading' | 'paragraph' | 'link' | 'button' | 'label' | 'list-item' | 'other';
+interface PageVersion {
+    version_number: number;
+    created_at: string;
+    created_by: string;
+    screenshot_desktop: ScreenshotInfo | null;
+    screenshot_mobile: ScreenshotInfo | null;
+    notes?: string;
+    approved?: boolean;
+    approved_by?: string;
+    approved_by_name?: string;
+    approved_at?: string;
+    round_number?: number;
+}
+interface ScreenshotInfo {
+    url: string;
+    uploaded_at: string;
+    uploaded_by: string;
+    file_name: string;
+    file_size: number;
+}
+interface AttachmentTranscription {
+    text: string;
+    language?: string;
+    duration?: number;
+    segments?: Array<{
+        start: number;
+        end: number;
+        text: string;
+    }>;
+}
+interface CommentAttachment {
+    id: string;
+    file_name: string;
+    file_url: string;
+    file_type: string;
+    file_size: number;
+    uploaded_at: string;
+    transcription?: AttachmentTranscription;
+}
+interface PageComment {
+    id: string;
+    user_id: string;
+    user_name: string;
+    user_role: UserRole;
+    version_number: number;
+    screenshot_type: 'desktop' | 'mobile';
+    comment: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    created_at: string;
+    updated_at?: string;
+    edited_at?: string;
+    resolved?: boolean;
+    parent_id?: string;
+    replies?: PageComment[];
+    mentions?: string[];
+    attachments?: CommentAttachment[];
+    metadata?: {
+        reviewType?: 'screenshot' | 'live';
+        viewMode?: 'desktop' | 'mobile';
+        elementMetadata?: unknown;
+        pageUrl?: string;
+        pagePath?: string;
+        cssSelector?: string;
+        source?: 'widget' | 'screenshot' | 'app' | 'content_editor';
+        changeType?: 'modified' | 'added' | 'deleted';
+        originalContent?: string;
+        newContent?: string;
+        paragraphIndex?: number;
+        hasScreenshot?: boolean;
+        screenshotUrl?: string;
+        screenshotType?: 'region' | 'full';
+        annotationsCount?: number;
+    };
+    selector?: string;
+    element_html?: string;
+    element_text?: string;
+    element_type?: string;
+    element_styles?: Record<string, string>;
+    viewport_size?: {
+        width: number;
+        height: number;
+    };
+    created_in_round?: number;
+    resolved_in_round?: number;
+    resolution_status?: ResolutionStatus;
+    resolution_description?: string;
+    needs_clarification?: boolean;
+    clarification_suggestion?: string;
+}
+interface Phase4Page {
+    page_name: string;
+    page_url?: string;
+    versions: PageVersion[];
+    comments: PageComment[];
+    textContent?: PageTextContent;
+    is_virtual_view?: boolean;
+    parent_url?: string;
+}
+interface Phase4Data {
+    demo_url?: string;
+    pages: Phase4Page[];
+    suggestions?: SectionSuggestion[];
+    rounds?: FeedbackRound[];
+    current_round?: number;
+    import_history?: ResolutionImportResult[];
+    project_approved?: boolean;
+    project_approved_at?: string;
+    project_approved_by?: string;
+    project_approved_by_name?: string;
+    completed_at?: string;
+    completed_by?: string;
+    completed_by_name?: string;
+    onboarding_completed?: boolean;
+    page_images?: PageImage[];
+}
+interface BaseFeedItem {
+    id: string;
+    pageName: string;
+    pageUrl?: string;
+    timestamp: string;
+    userId: string;
+    userName: string;
+    userRole: UserRole;
+}
+interface FeedbackFeedItem extends BaseFeedItem {
+    type: 'feedback';
+    comment: PageComment;
+    screenshotUrl?: string;
+    versionNumber: number;
+    screenshotType: 'desktop' | 'mobile';
+    position: {
+        x: number;
+        y: number;
+    };
+    createdInRound?: number;
+    resolvedInRound?: number;
+    resolutionStatus?: ResolutionStatus;
+    resolutionDescription?: string;
+}
+interface TextEditFeedItem extends BaseFeedItem {
+    type: 'text_edit';
+    edit: TextEdit;
+    language: string;
+    sectionName: string;
+    blockType: 'heading' | 'text' | 'list';
+    tagName: string;
+    originalContent: string;
+    newContent: string;
+}
+interface ImageFeedItem extends BaseFeedItem {
+    type: 'image_feedback';
+    imageId: string;
+    imageUrl: string;
+    imageAltText?: string;
+    imageStatus: ImageStatus;
+    comment: ImageComment;
+    usedOnPages: string[];
+    replacementUrl?: string;
+}
+type FeedItem = FeedbackFeedItem | TextEditFeedItem | ImageFeedItem;
+declare const isFeedbackItem: (item: FeedItem) => item is FeedbackFeedItem;
+declare const isTextEditItem: (item: FeedItem) => item is TextEditFeedItem;
+declare const isImageFeedItem: (item: FeedItem) => item is ImageFeedItem;
+interface WidgetSession {
+    id: string;
+    project_id: string;
+    token: string;
+    created_by: string;
+    created_at: string;
+    expires_at: string;
+    last_activity: string;
+    guest_name?: string;
+    page_url?: string;
+    user_agent?: string;
+    is_active: boolean;
+}
+interface WidgetSessionCreate {
+    project_id: string;
+    page_url?: string;
+    guest_name?: string;
+}
+interface WidgetSessionValidation {
+    valid: boolean;
+    error?: string;
+    session?: {
+        id: string;
+        project_id: string;
+        expires_at: string;
+        guest_name?: string;
+    };
+    project?: {
+        id: string;
+        name: string;
+        status: ProjectStatus;
+        pages: {
+            page_name: string;
+            page_url: string;
+            comment_count: number;
+            has_approved_version: boolean;
+        }[];
+    };
+}
+
+/**
+ * Categories for maintenance items
+ */
+type MaintenanceCategory = 'bug_fix' | 'performance' | 'security' | 'content_update' | 'design_tweak' | 'new_feature' | 'new_section' | 'new_page' | 'campaign' | 'seo' | 'accessibility' | 'technical_debt' | 'other';
+/**
+ * Priority levels for maintenance items
+ */
+type MaintenancePriority = 'critical' | 'high' | 'medium' | 'low';
+/**
+ * Status workflow for maintenance items
+ * backlog → scheduled → in_progress → review → completed
+ *                                        ↓
+ *                                    wont_fix
+ */
+type MaintenanceItemStatus = 'backlog' | 'scheduled' | 'in_progress' | 'review' | 'completed' | 'wont_fix';
+/**
+ * Configuration for recurring maintenance tasks
+ */
+interface RecurringConfig {
+    enabled: boolean;
+    frequency: 'weekly' | 'monthly' | 'quarterly';
+    next_due: string;
+    last_completed?: string;
+}
+/**
+ * Comment on a maintenance item
+ */
+interface MaintenanceComment {
+    id: string;
+    user_id: string;
+    user_name: string;
+    user_role?: UserRole;
+    comment: string;
+    created_at: string;
+    edited_at?: string;
+    attachments?: CommentAttachment[];
+    parent_id?: string;
+    replies?: MaintenanceComment[];
+    is_internal?: boolean;
+    mentions?: string[];
+}
+/**
+ * Status transition history for maintenance items
+ */
+interface StatusTransition {
+    from_status: MaintenanceItemStatus;
+    to_status: MaintenanceItemStatus;
+    changed_at: string;
+    changed_by: string;
+    changed_by_name: string;
+}
+/**
+ * A single maintenance item (bug, feature request, improvement, etc.)
+ */
+interface MaintenanceItem {
+    id: string;
+    title: string;
+    description: string;
+    category: MaintenanceCategory;
+    priority: MaintenancePriority;
+    status: MaintenanceItemStatus;
+    page_name?: string;
+    page_url?: string;
+    element_selector?: string;
+    screenshot_url?: string;
+    position?: {
+        x: number;
+        y: number;
+    };
+    scheduled_for?: string;
+    due_date?: string;
+    estimated_hours?: number;
+    recurring?: RecurringConfig;
+    source?: 'widget' | 'manual' | string;
+    created_at: string;
+    created_by: string;
+    created_by_name: string;
+    created_by_role?: UserRole;
+    updated_at?: string;
+    resolved_at?: string;
+    resolved_by?: string;
+    resolved_by_name?: string;
+    resolution_notes?: string;
+    comments?: MaintenanceComment[];
+    attachments?: CommentAttachment[];
+    related_items?: string[];
+    blocks?: string[];
+    blocked_by?: string[];
+    status_history?: StatusTransition[];
+    total_time_minutes?: number;
+    metadata?: {
+        type?: 'text-edit' | 'general-feedback' | 'element-feedback';
+        originalContent?: string;
+        newContent?: string;
+        source?: 'widget' | 'manual' | 'phase4';
+        aiValidation?: {
+            clarityScore?: number;
+            conversationThread?: Array<{
+                role: 'user' | 'ai';
+                content: string;
+                timestamp: string;
+                type?: string;
+            }>;
+            summary?: {
+                clarificationQuestions?: string[];
+                finalClarityScore?: number;
+                wasInitiallyClear?: boolean;
+            };
+        };
+        [key: string]: unknown;
+    };
+}
+/**
+ * Summary stats for a maintenance cycle
+ */
+interface MaintenanceCycleSummary {
+    total_items: number;
+    completed: number;
+    carried_over: number;
+    new_items_added: number;
+    hours_spent?: number;
+}
+/**
+ * A maintenance cycle (similar to FeedbackRound in Phase 4)
+ */
+interface MaintenanceCycle {
+    id: string;
+    cycle_number: number;
+    name: string;
+    type: 'sprint' | 'monthly' | 'quarterly' | 'ad_hoc';
+    started_at: string;
+    started_by: string;
+    started_by_name: string;
+    ended_at?: string;
+    ended_by?: string;
+    ended_by_name?: string;
+    status: 'active' | 'completed' | 'cancelled';
+    summary?: MaintenanceCycleSummary;
+}
+/**
+ * Quick stats cache for Phase 5 dashboard
+ */
+interface MaintenanceStats {
+    total_items: number;
+    open_items: number;
+    completed_items: number;
+    critical_count: number;
+    high_count: number;
+    by_category: Record<MaintenanceCategory, number>;
+    last_updated: string;
+}
+/**
+ * Credential type for categorization
+ */
+type CredentialType = 'hosting' | 'cms' | 'ftp' | 'database' | 'email' | 'api' | 'other';
+/**
+ * Stored credential for accessing client sites
+ * Used in Phase 5 for maintenance access
+ */
+interface StoredCredential {
+    id: string;
+    name: string;
+    type?: CredentialType;
+    url?: string;
+    username?: string;
+    password?: string;
+    notes?: string;
+    created_at: string;
+    created_by: string;
+    created_by_name: string;
+    updated_at?: string;
+    updated_by?: string;
+    updated_by_name?: string;
+}
+/**
+ * Quote status workflow
+ * draft → pending_review → quoted → approved/rejected → in_progress → completed
+ */
+type QuoteStatus = 'draft' | 'pending_review' | 'quoted' | 'approved' | 'rejected' | 'in_progress' | 'completed';
+/**
+ * A quote/estimate for a maintenance item
+ */
+interface MaintenanceQuote {
+    id: string;
+    status: QuoteStatus;
+    estimated_hours?: number;
+    hourly_rate?: number;
+    fixed_price?: number;
+    currency: 'EUR' | 'USD' | 'GBP';
+    line_items?: {
+        description: string;
+        hours?: number;
+        amount: number;
+    }[];
+    quote_notes?: string;
+    valid_until?: string;
+    client_response_notes?: string;
+    responded_at?: string;
+    responded_by?: string;
+    responded_by_name?: string;
+    quoted_at?: string;
+    quoted_by?: string;
+    quoted_by_name?: string;
+    revision_number: number;
+    previous_quotes?: MaintenanceQuote[];
+}
+/**
+ * Activity log entry for maintenance items
+ */
+interface MaintenanceActivity {
+    id: string;
+    item_id: string;
+    type: 'created' | 'status_changed' | 'priority_changed' | 'assigned' | 'comment_added' | 'quote_requested' | 'quote_submitted' | 'quote_approved' | 'quote_rejected' | 'attachment_added' | 'completed';
+    user_id: string;
+    user_name: string;
+    user_role?: UserRole;
+    timestamp: string;
+    details?: {
+        from?: string;
+        to?: string;
+        comment?: string;
+        amount?: number;
+    };
+}
+/**
+ * Extended maintenance item with quote support
+ */
+interface MaintenanceItemExtended extends MaintenanceItem {
+    quote?: MaintenanceQuote;
+    requires_quote?: boolean;
+    assigned_to?: string;
+    assigned_to_name?: string;
+    activity?: MaintenanceActivity[];
+    is_urgent?: boolean;
+    is_pinned?: boolean;
+    client_visible?: boolean;
+}
+/**
+ * Phase 5: Manage & Maintain data structure
+ * For ongoing post-launch maintenance and feedback
+ */
+interface Phase5Data {
+    live_url?: string;
+    staging_url?: string;
+    items: MaintenanceItem[];
+    cycles?: MaintenanceCycle[];
+    current_cycle?: number;
+    stats?: MaintenanceStats;
+    sla?: {
+        critical_response_hours: number;
+        high_response_hours: number;
+        medium_response_hours: number;
+        low_response_hours: number;
+    };
+    credentials?: StoredCredential[];
+    pricing?: {
+        default_hourly_rate: number;
+        currency: 'EUR' | 'USD' | 'GBP';
+    };
+}
+/**
+ * Time entry for logging work done on maintenance items
+ */
+interface TimeEntry {
+    id: string;
+    project_id: string;
+    maintenance_item_id?: string;
+    user_id: string;
+    agency_id?: string;
+    logged_date: string;
+    duration_minutes: number;
+    description?: string;
+    billable: boolean;
+    user_name?: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Hour package status
+ */
+type HourPackageStatus = 'active' | 'expired' | 'depleted';
+/**
+ * Hour package (strippenkaart) for a project
+ */
+interface HourPackage {
+    id: string;
+    project_id: string;
+    agency_id?: string;
+    name: string;
+    total_minutes: number;
+    used_minutes: number;
+    remaining_minutes: number;
+    purchased_at: string;
+    expires_at?: string;
+    status: HourPackageStatus;
+    price_cents?: number;
+    currency: 'EUR' | 'USD' | 'GBP';
+    stripe_payment_id?: string;
+    notes?: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Internal note for agency team only
+ */
+interface InternalNote {
+    id: string;
+    notable_type: 'project' | 'maintenance_item' | 'meeting';
+    notable_id: string;
+    project_id: string;
+    user_id: string;
+    user_name: string;
+    body: string;
+    is_pinned: boolean;
+    title?: string;
+    meeting_date?: string;
+    content_html?: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Domain monitor check status
+ */
+type DomainCheckStatus = 'pending' | 'ok' | 'warning' | 'error';
+/**
+ * Domain/SSL monitor for a project
+ */
+interface DomainMonitor {
+    id: string;
+    project_id: string;
+    agency_id?: string;
+    domain: string;
+    ssl_expiry?: string;
+    domain_expiry?: string;
+    last_checked?: string;
+    check_status: DomainCheckStatus;
+    check_error?: string;
+    alerts_enabled: boolean;
+    alert_days: number[];
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Uptime monitor for a project
+ */
+interface UptimeMonitor {
+    id: string;
+    project_id: string;
+    agency_id?: string;
+    url: string;
+    name?: string;
+    method: 'GET' | 'HEAD';
+    expected_status_code: number;
+    timeout_ms: number;
+    check_interval_minutes: number;
+    is_active: boolean;
+    is_up: boolean;
+    last_status_code?: number;
+    last_response_time_ms?: number;
+    last_checked_at?: string;
+    last_error?: string;
+    consecutive_failures: number;
+    uptime_percentage?: number;
+    avg_response_time_ms?: number;
+    total_checks_30d: number;
+    failed_checks_30d: number;
+    last_down_at?: string;
+    last_up_at?: string;
+    down_since?: string;
+    alerts_enabled: boolean;
+    alert_threshold: number;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Individual uptime check result
+ */
+interface UptimeCheck {
+    id: string;
+    monitor_id: string;
+    checked_at: string;
+    is_up: boolean;
+    status_code?: number;
+    response_time_ms?: number;
+    error?: string;
+}
+/**
+ * Uptime incident (downtime period)
+ */
+interface UptimeIncident {
+    id: string;
+    monitor_id: string;
+    project_id: string;
+    started_at: string;
+    ended_at?: string;
+    duration_minutes?: number;
+    error_type?: 'timeout' | 'connection_refused' | 'dns_error' | 'ssl_error' | 'http_error' | 'unknown';
+    last_error?: string;
+    checks_failed: number;
+    is_resolved: boolean;
+    created_at: string;
+}
+/**
+ * Changelog entry category
+ */
+type ChangelogCategory = 'bugfix' | 'improvement' | 'feature' | 'content' | 'security';
+/**
+ * Changelog entry for a project
+ */
+interface ChangelogEntry {
+    id: string;
+    project_id: string;
+    maintenance_item_id?: string;
+    title: string;
+    description?: string;
+    category: ChangelogCategory;
+    is_public: boolean;
+    published_at?: string;
+    created_by: string;
+    created_by_name: string;
+    created_at: string;
+}
+/**
+ * Monthly report data structure
+ */
+interface MonthlyReportData {
+    period: {
+        start: string;
+        end: string;
+    };
+    summary: {
+        tickets_completed: number;
+        tickets_created: number;
+        hours_logged: number;
+        hours_remaining: number;
+    };
+    tickets_by_category: Record<MaintenanceCategory, number>;
+    time_breakdown: Array<{
+        description: string;
+        minutes: number;
+        user_name?: string;
+    }>;
+    open_items: Array<{
+        title: string;
+        priority: MaintenancePriority;
+        status: MaintenanceItemStatus;
+        category: MaintenanceCategory;
+    }>;
+    changelog: Array<{
+        title: string;
+        category: ChangelogCategory;
+        date: string;
+    }>;
+}
+/**
+ * Monthly report for a project
+ */
+interface MonthlyReport {
+    id: string;
+    project_id: string;
+    agency_id?: string;
+    report_month: string;
+    data: MonthlyReportData;
+    pdf_url?: string;
+    sent_to_client: boolean;
+    sent_at?: string;
+    created_at: string;
+}
+/**
+ * Improvement suggestion category
+ */
+type SuggestionCategory = 'performance' | 'ux' | 'seo' | 'design' | 'functionality' | 'security' | 'accessibility';
+/**
+ * Improvement suggestion impact level
+ */
+type SuggestionImpact = 'low' | 'medium' | 'high';
+/**
+ * Improvement suggestion status
+ */
+type SuggestionStatus = 'draft' | 'proposed' | 'accepted' | 'rejected' | 'converted';
+/**
+ * Improvement suggestion for proactive agency recommendations
+ */
+interface ImprovementSuggestion {
+    id: string;
+    project_id: string;
+    title: string;
+    description: string;
+    category: SuggestionCategory;
+    impact: SuggestionImpact;
+    effort_hours?: number;
+    estimated_cost_cents?: number;
+    currency: 'EUR' | 'USD' | 'GBP';
+    status: SuggestionStatus;
+    proposed_at?: string;
+    client_response_at?: string;
+    client_response_notes?: string;
+    converted_item_id?: string;
+    created_by: string;
+    created_by_name: string;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Extended Phase 5 notification types
+ */
+type Phase5NotificationType = 'maintenance_item_created' | 'maintenance_item_completed' | 'maintenance_priority_alert' | 'maintenance_cycle_started' | 'maintenance_cycle_closed' | 'hour_package_low' | 'time_entry_added' | 'suggestion_proposed' | 'suggestion_accepted' | 'suggestion_rejected' | 'domain_expiry_warning' | 'monthly_report_ready';
+
+type UserRole = 'super_admin' | 'admin' | 'manager' | 'client';
+interface User {
+    id: string;
+    email: string;
+    name: string;
+    role: UserRole;
+    agency_id?: string | null;
+    preferred_language?: 'nl' | 'en' | 'es';
+    avatar_url?: string | null;
+    preferences?: UserPreferences | null;
+    created_at?: string;
+}
+interface UserPreferences {
+    language: string;
+    email_notifications: {
+        project_updates: boolean;
+        project_status_changes: boolean;
+        comments: boolean;
+        mentions: boolean;
+        weekly_summary: boolean;
+    };
+}
+interface Agency {
+    id: string;
+    name: string;
+    slug: string;
+    project_limit?: number | null;
+    logo_url?: string | null;
+    created_at?: string;
+    created_by?: string | null;
+    is_active?: boolean;
+    plan_type?: PlanType;
+    subscription_status?: SubscriptionStatus;
+    subscription_start_date?: string;
+    subscription_end_date?: string | null;
+    features?: {
+        performance_analysis?: boolean;
+        seo_audit?: boolean;
+        uptime_monitoring?: boolean;
+        [key: string]: boolean | undefined;
+    };
+    seo_credits_limit?: number;
+    seo_credits_used?: number;
+    module_limits?: ModuleLimits;
+    stripe_customer_id?: string | null;
+    stripe_subscription_id?: string | null;
+    stripe_subscription_status?: 'active' | 'past_due' | 'canceled' | 'incomplete' | 'trialing' | null;
+    stripe_current_period_end?: string | null;
+    billing_email?: string | null;
+}
+type ProjectStatus = 'draft' | 'submitted' | 'in_development' | 'feedback' | 'in_management' | 'completed' | 'archived';
+type ProjectType = 'standard' | 'review_only' | 'manage_only';
+/**
+ * Project-level monitoring feature flags
+ * These can only be enabled if the agency has the feature available
+ */
+interface ProjectMonitoringFeatures {
+    seo_enabled?: boolean;
+    performance_enabled?: boolean;
+    uptime_enabled?: boolean;
+    analytics_enabled?: boolean;
+}
+interface Project {
+    id: string;
+    agency_id?: string;
+    created_by?: string;
+    user_id?: string;
+    name: string;
+    status?: ProjectStatus;
+    project_type?: ProjectType;
+    source_url?: string | null;
+    current_step?: number;
+    locked_phases?: number[];
+    unlocked_phases?: number[];
+    disabled_phases?: number[];
+    enabled_modules?: ModuleType[];
+    visible_modules?: ModuleType[];
+    data?: ProjectData;
+    created_at?: string;
+    updated_at?: string;
+    enabled_features?: string[];
+    monitoring_features?: ProjectMonitoringFeatures;
+    analytics_enabled?: boolean;
+    agency?: Agency;
+    budget_hours_per_month?: number | null;
+    budget_hourly_rate_cents?: number | null;
+    agency_notes?: string | null;
+}
+interface ProjectMember {
+    id: string;
+    project_id: string;
+    user_id: string;
+    role: 'manager' | 'client';
+    created_at?: string;
+    user?: User;
+}
+interface ProjectData {
+    phase1?: Phase1Data;
+    phase2?: Phase2Data;
+    phase3?: BuildSpecData;
+    phase4?: Phase4Data;
+    phase5?: Phase5Data;
+    buildSpec?: BuildSpecData;
+}
+interface ProjectShare {
+    id: string;
+    project_id: string;
+    share_token: string;
+    created_by: string;
+    expires_at?: string | null;
+    access_level: 'view_only';
+    created_at?: string;
+    updated_at?: string;
+}
+interface GeneralComment {
+    id: string;
+    project_id: string;
+    phase?: number | null;
+    page_name?: string | null;
+    section_id?: string | null;
+    author_id?: string | null;
+    guest_name?: string | null;
+    content: string;
+    mentions?: string[];
+    parent_id?: string | null;
+    is_resolved?: boolean;
+    created_at?: string;
+    updated_at?: string;
+    author?: User;
+    replies?: GeneralComment[];
+}
+interface PerformanceMetrics {
+    performance: number;
+    accessibility: number;
+    bestPractices: number;
+    seo: number;
+    firstContentfulPaint: number;
+    largestContentfulPaint: number;
+    totalBlockingTime: number;
+    cumulativeLayoutShift: number;
+    speedIndex: number;
+}
+interface PerformanceAudit {
+    id: string;
+    title: string;
+    description: string;
+    score: number | null;
+    scoreDisplayMode?: 'binary' | 'numeric' | 'informative' | 'notApplicable';
+    displayValue?: string;
+    numericValue?: number;
+    numericUnit?: string;
+    details?: unknown;
+}
+interface PerformanceOpportunity extends PerformanceAudit {
+    overallSavingsMs?: number;
+    overallSavingsBytes?: number;
+}
+interface PerformanceReport {
+    id: string;
+    projectId: string;
+    pageName: string;
+    pageUrl: string;
+    strategy: 'mobile' | 'desktop';
+    metrics: PerformanceMetrics;
+    audits: PerformanceAudit[];
+    opportunities: PerformanceOpportunity[];
+    diagnostics: PerformanceAudit[];
+    fetchTime: string;
+    lighthouseVersion: string;
+    rawData?: unknown;
+    createdAt?: string;
+}
+interface ProjectPerformanceUsage {
+    projectId: string;
+    checksUsed: number;
+    checksLimit: number;
+    lastCheckAt?: string;
+    reports: PerformanceReport[];
+}
+interface ProjectFeature {
+    id: string;
+    projectId: string;
+    featureName: string;
+    enabled: boolean;
+    enabledBy?: string;
+    enabledAt?: string;
+    createdAt?: string;
+}
+interface SeoAuditIssue {
+    type: 'error' | 'warning' | 'info';
+    category: string;
+    title: string;
+    description: string;
+    url?: string;
+    selector?: string;
+    impact?: 'critical' | 'serious' | 'moderate' | 'minor';
+}
+interface SeoAuditResult {
+    url: string;
+    title?: string;
+    metaDescription?: string;
+    h1?: string[];
+    canonicalUrl?: string;
+    robotsDirectives?: string[];
+    issues: SeoAuditIssue[];
+    scores?: {
+        overall?: number;
+        content?: number;
+        technical?: number;
+        mobile?: number;
+    };
+    pageData?: Record<string, unknown>;
+}
+interface SeoReport {
+    id: string;
+    projectId: string;
+    pageName: string;
+    pageUrl: string;
+    apifyRunId: string;
+    apifyDatasetId: string;
+    results: SeoAuditResult[];
+    createdAt: string;
+    createdBy: string;
+}
+
+interface ElementMetadata {
+    tagName: string;
+    id: string | null;
+    classes: string[];
+    text: string;
+    bbox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+interface AnnotationBody {
+    type: 'TextualBody';
+    text: string;
+    format: 'text/plain';
+    language: string;
+}
+interface AnnotationTarget {
+    type: 'SpecificResource';
+    source: string;
+    selector: {
+        type: 'CssSelector';
+        value: string;
+    }[];
+}
+interface Annotation {
+    type: 'Annotation';
+    id?: string;
+    wizardPhase: 4;
+    projectId: string;
+    pageUrl: string;
+    body: AnnotationBody;
+    target: AnnotationTarget;
+    elementMetadata: ElementMetadata;
+    created_at: string;
+    created_by: string;
+}
+
+/**
+ * Framed API Client
+ *
+ * Handles communication with Framed's AI services (premium features).
+ * Uses the customer's API key for authentication.
+ */
+interface FramedApiError {
+    message: string;
+    code?: string;
+    status?: number;
+}
+declare class FramedApiClient {
+    private apiKey;
+    constructor(apiKey?: string);
+    /**
+     * Check if the client is configured with an API key.
+     */
+    get isEnabled(): boolean;
+    /**
+     * Make a POST request to a Framed API endpoint.
+     *
+     * @param endpoint - The endpoint path (e.g., 'sdk-ai-translate')
+     * @param data - The request payload
+     * @returns The response data
+     * @throws Error if API key is not configured or request fails
+     */
+    post<T>(endpoint: string, data: unknown): Promise<T>;
+    /**
+     * Make a GET request to a Framed API endpoint.
+     *
+     * @param endpoint - The endpoint path
+     * @param params - Optional query parameters
+     * @returns The response data
+     */
+    get<T>(endpoint: string, params?: Record<string, string>): Promise<T>;
+}
+
+/**
+ * User Supabase Client Factory
+ *
+ * Creates and manages a Supabase client for the customer's own database.
+ * This is where project data, tasks, and file uploads are stored.
+ */
+
+/**
+ * Initialize the user's Supabase client.
+ *
+ * @param url - The customer's Supabase URL (e.g., https://xxx.supabase.co)
+ * @param key - The customer's Supabase anon key
+ * @returns The initialized Supabase client
+ */
+declare function initUserSupabase(url: string, key: string): SupabaseClient;
+/**
+ * Get the current user Supabase client.
+ *
+ * @returns The Supabase client
+ * @throws Error if client has not been initialized
+ */
+declare function getUserSupabase(): SupabaseClient;
+/**
+ * Check if the Supabase client has been initialized.
+ */
+declare function isSupabaseInitialized(): boolean;
+/**
+ * Reset the Supabase client (useful for testing or logout).
+ */
+declare function resetUserSupabase(): void;
+
+/**
+ * Callback Implementations
+ *
+ * These functions implement the callback interfaces used by wizard components.
+ * They use the dual-client architecture:
+ * - File uploads → User's Supabase storage
+ * - AI features → Framed API
+ */
+
+/**
+ * Upload a file to the user's Supabase storage.
+ *
+ * @param file - The file to upload
+ * @param bucket - The storage bucket name (default: 'uploads')
+ * @param path - Optional custom path for the file
+ * @returns Upload result with URL and metadata
+ */
+declare function uploadFile(file: File, bucket?: string, path?: string): Promise<UploadResult>;
+/**
+ * Upload a font file to the user's Supabase storage.
+ *
+ * @param file - The font file to upload
+ * @returns Upload result with font-specific metadata
+ */
+declare function uploadFont(file: File): Promise<UploadResult>;
+/**
+ * Upload a logo file to the user's Supabase storage.
+ *
+ * @param file - The logo image file to upload
+ * @returns Upload result with URL
+ */
+declare function uploadLogo(file: File): Promise<UploadResult>;
+/**
+ * Translate content using the Framed AI API.
+ *
+ * @param framedApi - The Framed API client instance
+ * @param value - The content to translate (language code to text mapping)
+ * @param primaryLanguage - The source language code
+ * @param targetLanguages - Array of target language codes
+ * @returns Translation result with translations and any errors
+ */
+declare function translateContent(framedApi: FramedApiClient, value: Record<string, string>, primaryLanguage: string, targetLanguages: string[]): Promise<TranslationResult>;
+/**
+ * Create the complete callbacks object for wizard components.
+ *
+ * @param framedApi - The Framed API client instance
+ * @returns Object with all wizard callback implementations
+ */
+declare function createWizardCallbacks(framedApi: FramedApiClient): {
+    onUploadFile: (file: File) => Promise<UploadResult>;
+    onUploadFont: (file: File) => Promise<UploadResult>;
+    onLogoUpload: (file: File) => Promise<void>;
+    onTranslateAll: (value: Record<string, string>, primaryLanguage: string, targetLanguages: string[]) => Promise<TranslationResult>;
+};
+
+interface LayoutOption {
+    id: string;
+    name: string;
+    description: string;
+    sections: {
+        type: string;
+        title: string;
+        requiresMedia: boolean;
+        requiresCTA: boolean;
+    }[];
+}
+interface PageTypeLayouts {
+    [key: string]: LayoutOption[];
+}
+declare const PAGE_LAYOUTS: PageTypeLayouts;
+declare const getLayoutsForPage: (pageId: string) => LayoutOption[];
+declare const getPageDisplayName: (pageId: string) => string;
+
+/**
+ * Date filtering utilities for Phase 4 feedback views
+ */
+interface DateRange {
+    startDate: Date | null;
+    endDate: Date | null;
+}
+interface DatePreset {
+    id: string;
+    label: string;
+    getRange: () => DateRange;
+}
+declare const DATE_PRESETS: DatePreset[];
+/**
+ * Check if a date string is within the given date range
+ */
+declare function isWithinDateRange(dateString: string, range: DateRange): boolean;
+/**
+ * Format a date range for display in the filter button
+ */
+declare function formatDateRangeLabel(range: DateRange): string;
+/**
+ * Check if a date range filter is active (has any date set)
+ */
+declare function isDateRangeActive(range: DateRange): boolean;
+/**
+ * Get an empty date range
+ */
+declare function getEmptyDateRange(): DateRange;
+
+/**
+ * Permission utilities for multi-tenant SaaS
+ * Source: framed-app/src/utils/permissions.ts
+ */
+
+/**
+ * Check if an agency's subscription is currently valid
+ */
+declare const isSubscriptionValid: (agency: Agency | null) => boolean;
+/**
+ * Get the effective project limit based on the agency's plan type
+ */
+declare const getEffectiveProjectLimit: (agency: Agency | null) => number | null;
+declare const canCreateProject: (user: User | null, agency: Agency | null, projectCount: number) => boolean;
+declare const canViewProject: (user: User | null, project: Project | null, members?: ProjectMember[]) => boolean;
+declare const canEditProject: (user: User | null, project: Project | null, members?: ProjectMember[]) => boolean;
+declare const canDeleteProject: (user: User | null, project: Project | null) => boolean;
+declare const canLockPhase: (user: User | null, project: Project | null) => boolean;
+/**
+ * Check if user can disable/enable phases (hide from navigation)
+ * Same permissions as phase locking - admins can control phase visibility
+ */
+declare const canDisablePhase: (user: User | null, project: Project | null) => boolean;
+/**
+ * Check if a phase is disabled (hidden from navigation)
+ */
+declare const isPhaseDisabled: (phase: number, project: Project | null) => boolean;
+/**
+ * Check if a phase is soft-locked (automatically disabled during review)
+ * Soft-lock applies to Phase 1 and 2 when project is in Phase 3+ or not in draft status
+ * Admins can override by adding phase to unlocked_phases
+ */
+declare const isSoftLocked: (phase: number, project: Project | null) => boolean;
+/**
+ * Check if user can unlock a soft-locked phase
+ * Same permissions as hard lock
+ */
+declare const canUnlockSoftLock: (user: User | null, project: Project | null) => boolean;
+/**
+ * Check if user can approve/reject section suggestions
+ * Only admins and super_admins can approve suggestions
+ */
+declare const canApproveSuggestion: (user: User | null, project: Project | null) => boolean;
+declare const canInviteUsers: (user: User | null) => boolean;
+declare const canManageProjectMembers: (user: User | null, project: Project | null) => boolean;
+declare const canRemoveUser: (actor: User | null, targetUser: User | null) => boolean;
+declare const canManageAgency: (user: User | null, agencyId: string) => boolean;
+declare const canCreateAgency: (user: User | null) => boolean;
+declare const canDeleteAgency: (user: User | null) => boolean;
+declare const canSetProjectLimit: (user: User | null) => boolean;
+declare const isSuperAdmin: (user: User | null) => boolean;
+declare const isAdmin: (user: User | null) => boolean;
+declare const isManager: (user: User | null) => boolean;
+declare const isClient: (user: User | null) => boolean;
+declare const hasRole: (user: User | null, role: User["role"]) => boolean;
+declare const hasHigherRole: (user: User | null, compareRole: User["role"]) => boolean;
+declare const hasEqualOrHigherRole: (user: User | null, compareRole: User["role"]) => boolean;
+declare const getRoleBadgeColor: (role: User["role"]) => string;
+declare const getRoleDisplayName: (role: User["role"]) => string;
+declare const getRoleBadge: (role: User["role"]) => string;
+declare const canManageTeam: (user: User | null) => boolean;
+/**
+ * Check if user has admin-level privileges (admin or super_admin)
+ * Use this for features that should be available to both admins and super admins
+ * Examples: export functionality, viewing admin-only UI elements
+ */
+declare const hasAdminPrivileges: (user: User | null) => boolean;
+/**
+ * Get display name for plan type
+ */
+declare const getPlanDisplayName: (planType: Agency["plan_type"]) => string;
+/**
+ * Get display name for subscription status
+ */
+declare const getSubscriptionStatusDisplayName: (status: Agency["subscription_status"]) => string;
+/**
+ * Get badge color for subscription status
+ */
+declare const getSubscriptionStatusBadgeColor: (status: Agency["subscription_status"]) => string;
+/**
+ * Get badge color for plan type
+ */
+declare const getPlanBadgeColor: (planType: Agency["plan_type"]) => string;
+/**
+ * Format date for display
+ */
+declare const formatSubscriptionDate: (dateString: string | null) => string;
+/**
+ * Get days remaining until subscription expires
+ */
+declare const getDaysRemaining: (endDate: string | null) => number | null;
+/**
+ * Check if user can configure modules for a project
+ * Only admins and super_admins can change module settings
+ */
+declare const canConfigureModules: (user: User | null, project: Project | null) => boolean;
+/**
+ * Check if user can access a specific phase based on module configuration
+ * Combines module availability with existing project permissions
+ */
+declare const canAccessPhase: (user: User | null, project: Project | null, phase: number, members?: ProjectMember[]) => boolean;
+/**
+ * Check if a module is available for a project (enabled)
+ */
+declare const isModuleAvailable: (project: Project | null, module: ModuleType) => boolean;
+
+/**
+ * Comment utilities - Pure functions for mention handling
+ * Source: framed-app/src/utils/commentUtils.ts
+ *
+ * Note: Upload functions are NOT included here as they require runtime
+ * dependencies (supabase). Only pure utility functions are exported.
+ *
+ * For UploadResult type, use the one from @framed/core types.
+ */
+/**
+ * Extract user IDs from @mentions in text
+ * Format: @[userId:userName] or @userName (if we have user list)
+ */
+declare function extractMentions(text: string, availableUsers?: Array<{
+    id: string;
+    name: string;
+}>): string[];
+/**
+ * Format text with @mentions highlighted
+ * Converts @[userId:userName] to styled mentions
+ */
+declare function formatMentions(text: string): string;
+
+/**
+ * Localized content utilities
+ * Source: framed-app/src/utils/localizedContent.ts
+ */
+
+/**
+ * Get language settings from Phase 1 functionality data
+ */
+interface LanguageSettings {
+    isMultilingual: boolean;
+    primaryLanguage: string;
+    additionalLanguages: string[];
+    allLanguages: string[];
+}
+declare const getLanguageSettings: (functionality?: {
+    languages?: {
+        is_multilingual: boolean;
+        primary_language: string;
+        additional_languages: string[];
+    };
+}) => LanguageSettings;
+/**
+ * Get display value for a LocalizableString
+ * Always returns a string, handling both old (string) and new (LocalizedContent) formats
+ */
+declare const getDisplayValue: (value: LocalizableString | undefined, languageSettings: LanguageSettings, displayLanguage?: string) => string;
+/**
+ * Update a LocalizableString value for a specific language
+ * Handles conversion from string to LocalizedContent if needed
+ */
+declare const updateLocalizedValue: (currentValue: LocalizableString | undefined, newValue: string, language: string, languageSettings: LanguageSettings) => LocalizableString;
+/**
+ * Convert form data to the appropriate format based on language settings
+ * Used when saving data - ensures format matches multilingual setting
+ */
+declare const normalizeLocalizedField: (value: LocalizableString | undefined, languageSettings: LanguageSettings) => LocalizableString;
+/**
+ * Check if a localized field has content in all required languages
+ */
+declare const isLocalizedFieldComplete: (value: LocalizableString | undefined, languageSettings: LanguageSettings, requireAllLanguages?: boolean) => boolean;
+/**
+ * Create initial localized content with empty values for all languages
+ */
+declare const createEmptyLocalizedContent: (languageSettings: LanguageSettings) => LocalizedContent;
+/**
+ * Migrate a single string value to localized content format
+ * Useful for database migrations or data upgrades
+ */
+declare const migrateToLocalized: (value: string, sourceLanguage: string, languageSettings: LanguageSettings) => LocalizedContent;
+
+/**
+ * Format file size for display
+ * Source: framed-app/src/utils/storage.ts (pure function extracted)
+ */
+declare const formatFileSize: (bytes: number) => string;
+
+/**
+ * Storage utilities - Stub implementations
+ *
+ * These are placeholder functions that log warnings.
+ * Actual storage operations should be handled by the parent app
+ * via FramedProvider callbacks (onUploadFile, onDeleteFile).
+ */
+interface UploadMediaOptions {
+    file: File;
+    projectId: string;
+    path?: string;
+}
+interface UploadMediaResult {
+    url: string;
+    path: string;
+}
+/**
+ * Upload media file to storage
+ * Stub - logs warning, actual upload should use FramedProvider callbacks
+ */
+declare function uploadMedia(_options: UploadMediaOptions): Promise<UploadMediaResult | null>;
+/**
+ * Delete media file from storage
+ * Stub - logs warning, actual delete should use FramedProvider callbacks
+ */
+declare function deleteMedia(_path: string): Promise<boolean>;
+
+/**
+ * Feature flag utilities
+ * Source: framed-app/src/utils/featureFlags.ts
+ */
+
+/**
+ * Check if a user/project has access to a specific feature
+ */
+declare const hasFeature: (user: User | null, project: Project | null, featureName: string) => boolean;
+/**
+ * Check if agency has a monitoring feature available
+ * This is the "capability" check - can the agency use this feature at all?
+ */
+declare const agencyHasMonitoringFeature: (project: Project | null, feature: "seo" | "performance" | "uptime" | "analytics") => boolean;
+/**
+ * Check if a monitoring feature is enabled for a specific project
+ * Returns true if:
+ * 1. Agency has the feature available AND
+ * 2. Project has the feature enabled (or no explicit setting = enabled by default)
+ *
+ * This allows agencies to selectively enable/disable features per project for billing
+ */
+declare const projectHasMonitoringFeature: (user: User | null, project: Project | null, feature: "seo" | "performance" | "uptime" | "analytics") => boolean;
+/**
+ * Check if performance analysis feature is available
+ * Available to:
+ * - Super admins (always)
+ * - Gold plan agencies (automatically)
+ * - Agencies with feature explicitly enabled
+ */
+declare const hasPerformanceAnalysis: (user: User | null, project: Project | null) => boolean;
+/**
+ * Check if SEO audit feature is available
+ * Available to:
+ * - Super admins (always)
+ * - Gold plan agencies (automatically)
+ * - Agencies with feature explicitly enabled
+ */
+declare const hasSeoAudit: (user: User | null, project: Project | null) => boolean;
+/**
+ * Get SEO audit credits info for an agency
+ */
+declare const getSeoCreditsInfo: (project: Project | null) => {
+    used: number;
+    limit: number;
+    remaining: number;
+};
+/**
+ * Check if AI content generation feature is available
+ * This includes:
+ * - AI content suggestions for sections
+ * - AI translation for multilingual content
+ * - Auto-generate all content feature
+ *
+ * Available to:
+ * - Super admins (always)
+ * - Gold plan agencies (automatically)
+ * - Silver plan agencies (automatically)
+ * - Agencies with feature explicitly enabled
+ */
+declare const hasAIContentGeneration: (user: User | null, project: Project | null) => boolean;
+/**
+ * Get all available features for a project
+ */
+declare const getAvailableFeatures: (user: User | null, project: Project | null) => string[];
+/**
+ * Feature display names for UI
+ */
+declare const FEATURE_NAMES: Record<string, string>;
+/**
+ * Feature descriptions for UI
+ */
+declare const FEATURE_DESCRIPTIONS: Record<string, string>;
+/**
+ * Monitoring feature display names for Phase 5
+ */
+declare const MONITORING_FEATURE_NAMES: Record<'seo' | 'performance' | 'uptime' | 'analytics', string>;
+/**
+ * Monitoring feature descriptions for Phase 5
+ */
+declare const MONITORING_FEATURE_DESCRIPTIONS: Record<'seo' | 'performance' | 'uptime' | 'analytics', string>;
+
+/**
+ * Shared comment factory utility
+ * Source: framed-app/src/utils/createComment.ts
+ *
+ * Ensures consistent comment structure across all views:
+ * - Page-level feedback (Phase4ReviewPageNew)
+ * - All feedback view (AllFeedbackView)
+ * - Mobile view (Phase4MobileView)
+ */
+
+interface CreateCommentOptions {
+    comment: string;
+    userId: string;
+    userName: string;
+    userRole?: UserRole;
+    attachments?: CommentAttachment[];
+    versionNumber?: number;
+    position?: {
+        x: number;
+        y: number;
+    };
+    screenshotType?: 'desktop' | 'mobile';
+    source?: 'app' | 'widget' | 'screenshot' | 'content_editor';
+    currentRound?: number;
+}
+/**
+ * Creates a standardized PageComment object with all required fields populated
+ */
+declare function createComment(options: CreateCommentOptions): PageComment;
+
+/**
+ * Backwards Compatibility Utilities
+ * Source: framed-app/src/utils/compatibility.ts
+ *
+ * Helper functions to bridge the old website-only data model with the new
+ * multi-project-type model. These ensure existing projects continue to work
+ * while new projects can use the enhanced features.
+ */
+
+/**
+ * Get the project category from Phase1Data, defaulting to 'website' for backwards compatibility
+ */
+declare function getProjectCategory(phase1: Phase1Data | undefined): ProjectCategory;
+/**
+ * Check if a project is e-commerce (supports both old and new data models)
+ */
+declare function isEcommerceProject(phase1: Phase1Data | undefined): boolean;
+/**
+ * Check if a project is a website (includes e-commerce as a website subtype for UI purposes)
+ */
+declare function isWebsiteBasedProject(phase1: Phase1Data | undefined): boolean;
+/**
+ * Check if a project category should show the traditional page/section wizard (Phase 2)
+ */
+declare function shouldShowTraditionalWizard(phase1: Phase1Data | undefined): boolean;
+/**
+ * Get pages from Phase1Data - supports both old (pages array) and new (screens array) formats
+ * Returns an array of page IDs for backwards compatibility
+ */
+declare function getPages(phase1: Phase1Data | undefined): string[];
+/**
+ * Get custom pages from Phase1Data - supports both old and new formats
+ */
+declare function getCustomPages(phase1: Phase1Data | undefined): string[];
+/**
+ * Get all screens from Phase1Data - returns screens array or converts pages to screens
+ */
+declare function getScreens(phase1: Phase1Data | undefined): ScreenDefinition[];
+declare function isDefaultPage(pageId: string): boolean;
+/**
+ * Get the default display name for a page ID
+ */
+declare function getDefaultPageName(pageId: string): string;
+/**
+ * Get the display name for a screen/page
+ */
+declare function getScreenDisplayName(screen: ScreenDefinition | string, phase1?: Phase1Data): string;
+/**
+ * Get the appropriate screen type label for a project category
+ */
+declare function getScreenTypeLabel(category: ProjectCategory, plural?: boolean): string;
+/**
+ * Get the default screen type for a project category
+ */
+declare function getDefaultScreenType(category: ProjectCategory): ScreenType;
+/**
+ * Migrate Phase1Data from old format to new format
+ * This is a non-destructive operation that adds new fields without removing old ones
+ */
+declare function migratePhase1Data(phase1: Phase1Data): Phase1Data;
+/**
+ * Check if Phase1Data needs migration
+ */
+declare function needsMigration(phase1: Phase1Data | undefined): boolean;
+interface ProjectCategoryInfo {
+    id: ProjectCategory;
+    name: string;
+    description: string;
+    icon: string;
+    examples: string[];
+}
+/**
+ * Get display information for project categories
+ */
+declare function getProjectCategoryInfo(category: ProjectCategory): ProjectCategoryInfo;
+/**
+ * Get all project categories with their display info
+ */
+declare function getAllProjectCategories(): ProjectCategoryInfo[];
+
+/**
+ * Utilities for collecting and filtering unified feed items
+ * Source: framed-app/src/utils/feedUtils.ts
+ *
+ * Combines feedback comments, text edits, and image feedback into a single chronological feed
+ */
+
+/**
+ * Get screenshot URL for a comment based on version and screenshot type
+ * For region captures from the widget, the screenshot is stored in comment.metadata.screenshotUrl
+ */
+declare function getScreenshotUrl(page: Phase4Page, comment: PageComment): string | undefined;
+/**
+ * Collect all feed items from Phase 4 pages and images
+ * Combines feedback comments, text edits, and image feedback into a single array
+ */
+declare function collectFeedItems(pages: Phase4Page[], pageImages?: PageImage[]): FeedItem[];
+type FeedTypeFilter = 'all' | 'feedback' | 'text_edits' | 'image_feedback';
+type FeedStatusFilter = 'all' | 'open' | 'resolved';
+interface FeedFilters {
+    type: FeedTypeFilter;
+    status: FeedStatusFilter;
+    page?: string;
+    language?: string;
+    round?: number;
+}
+/**
+ * Filter feed items based on selected filters
+ */
+declare function filterFeedItems(items: FeedItem[], filters: FeedFilters): FeedItem[];
+interface GroupedFeedItems {
+    [pageName: string]: FeedItem[];
+}
+/**
+ * Group feed items by page name
+ */
+declare function groupFeedItemsByPage(items: FeedItem[]): GroupedFeedItems;
+interface FeedStats {
+    total: number;
+    feedbackCount: number;
+    textEditCount: number;
+    imageFeedbackCount: number;
+    openFeedback: number;
+    resolvedFeedback: number;
+    openTextEdits: number;
+    resolvedTextEdits: number;
+    openImageFeedback: number;
+    resolvedImageFeedback: number;
+    pagesAffected: number;
+    languagesUsed: string[];
+}
+/**
+ * Calculate statistics for feed items
+ */
+declare function calculateFeedStats(items: FeedItem[]): FeedStats;
+/**
+ * Get available languages from feed items
+ */
+declare function getAvailableLanguages(items: FeedItem[]): string[];
+/**
+ * Get available pages from feed items
+ */
+declare function getAvailablePages(items: FeedItem[]): string[];
+
+/**
+ * Resolution Report Parser
+ * Source: framed-app/src/utils/resolutionParser.ts
+ *
+ * Parses markdown resolution reports from AI agents and applies changes to feedback
+ *
+ * Supports multiple formats:
+ * 1. Checkbox format: **ID:** `feedback-id` with **Status:** [X] DONE / [ ] MANUAL / [ ] SKIPPED
+ * 2. Simple format: ## Resolved Items / ## Unable to Resolve with - [id]: description
+ * 3. Page-grouped format: ### Home Page (X items) with - [id]: description
+ * 4. Mixed format with Notes, Clarification sections, etc.
+ */
+
+interface ResolutionParseResult {
+    success: boolean;
+    resolved: ParsedResolutionItem[];
+    unable_to_resolve: ParsedResolutionItem[];
+    needs_clarification: ParsedResolutionItem[];
+    unmatched_ids: string[];
+    total_parsed: number;
+    errors: string[];
+    notes?: string;
+}
+interface ApplyResolutionOptions {
+    user: User;
+    roundNumber: number;
+    createNotesForUnmatched?: boolean;
+}
+/**
+ * Parse a resolution markdown report
+ * Handles various AI response formats including page-grouped items
+ */
+declare function parseResolutionReport(markdown: string, existingIds: string[]): ResolutionParseResult;
+/**
+ * Apply parsed resolutions to Phase4 data
+ * For "needs_clarification" items, creates a reply asking for clarification
+ */
+declare function applyResolutions(phase4Data: Phase4Data, parsed: ResolutionParseResult, options: ApplyResolutionOptions): {
+    updatedData: Phase4Data;
+    importResult: ResolutionImportResult;
+};
+/**
+ * Get all feedback IDs from Phase4 data
+ */
+declare function getAllFeedbackIds(phase4Data: Phase4Data): string[];
+/**
+ * Count feedback statistics for a round
+ */
+declare function countRoundStats(phase4Data: Phase4Data, roundNumber: number): {
+    total: number;
+    open: number;
+    resolved: number;
+    unable: number;
+};
+/**
+ * Calculate summary when closing a round
+ */
+declare function calculateRoundSummary(phase4Data: Phase4Data, roundNumber: number): {
+    total_items: number;
+    resolved_in_round: number;
+    carried_over: number;
+    unable_to_resolve: number;
+    new_items_added: number;
+};
+/**
+ * Migrate existing comments to Round 1
+ * Called when first round is started on a project with existing comments
+ */
+declare function migrateToRounds(phase4Data: Phase4Data, userId: string, userName: string): Phase4Data;
+
+/**
+ * Prompt Generator Utilities
+ * Source: framed-app/src/utils/promptGenerator.ts
+ *
+ * Generates AI prompts and exports for project data
+ */
+
+/**
+ * Generate a natural language prompt for AI website builders
+ */
+declare const generateNaturalLanguagePrompt: (data: ProjectData) => string;
+/**
+ * Generate JSON export for programmatic use
+ */
+declare const generateJSONExport: (data: ProjectData) => Record<string, unknown>;
+/**
+ * Generate a short prompt (max 1000 characters) for AI builders with limited input
+ */
+declare const generateShortPrompt: (data: Phase1Data, isNl?: boolean) => string;
+/**
+ * Collect all media URLs from project
+ */
+declare const collectProjectMedia: (data: ProjectData) => string[];
+/**
+ * Generate planning section for project
+ * Stub - full implementation in framed-app
+ */
+declare const generatePlanningSection: (data: Phase1Data, isNl?: boolean) => string;
+/**
+ * Generate project instructions markdown
+ * Stub - full implementation in framed-app
+ */
+declare const generateProjectInstructionsMd: (data: Phase1Data, isNl?: boolean) => string;
+/**
+ * Enhanced prompt response from AI enhancement
+ */
+interface EnhancedPromptResponse {
+    enhanced_prompt: string;
+    planning_section: string;
+    project_instructions_md: string;
+    error?: string;
+}
+
+/**
+ * Text diff utilities
+ *
+ * Provides word-level diff computation for text comparison.
+ * Used by CompactDiff component and text editing features.
+ */
+interface DiffPart {
+    value: string;
+    added?: boolean;
+    removed?: boolean;
+}
+/**
+ * Simple word-level diff implementation
+ * For production, consider using the 'diff' npm package
+ */
+declare function computeTextDiff(original: string, current: string): DiffPart[];
+
+/**
+ * Text content utilities for managing page text edits
+ * Pure functions for content manipulation - no API calls
+ *
+ * Source: framed-app/src/services/textContentService.ts (pure functions only)
+ */
+
+declare const LANGUAGE_LABELS: Record<string, string>;
+interface ExportedChange {
+    sectionName: string;
+    blockType: string;
+    tagName: string;
+    original: string;
+    updated: string;
+    editCount: number;
+    lastEditedBy: string;
+    lastEditedAt: string;
+}
+interface TextChangesExport {
+    pageUrl: string;
+    language: string;
+    crawledAt: string;
+    exportedAt: string;
+    totalBlocks: number;
+    changedBlocks: number;
+    changes: ExportedChange[];
+}
+/**
+ * Add or update language content in PageTextContent
+ */
+declare function addLanguageContent(textContent: PageTextContent | undefined, pageUrl: string, languageContent: LanguageContent): PageTextContent;
+/**
+ * Apply a text edit to a block and return updated content
+ */
+declare function applyBlockEdit(textContent: PageTextContent, language: string, sectionId: string, blockId: string, newContent: string, userId: string, userName: string, userRole: UserRole, comment?: string): PageTextContent;
+/**
+ * Apply list items edit
+ */
+declare function applyListEdit(textContent: PageTextContent, language: string, sectionId: string, blockId: string, newItems: string[], userId: string, userName: string, userRole: UserRole, comment?: string): PageTextContent;
+/**
+ * Restore block to original content
+ */
+declare function restoreBlockToOriginal(textContent: PageTextContent, language: string, sectionId: string, blockId: string, userId: string, userName: string, userRole: UserRole): PageTextContent;
+/**
+ * Check if block has been modified
+ */
+declare function isBlockModified(block: ContentBlock): boolean;
+/**
+ * Get count of modified blocks in a language
+ */
+declare function getModifiedCount(langContent: LanguageContent): number;
+/**
+ * Get total block count
+ */
+declare function getTotalBlockCount(langContent: LanguageContent): number;
+/**
+ * Get edit history for specific block
+ */
+declare function getBlockHistory(langContent: LanguageContent, blockId: string): TextEdit[];
+/**
+ * Get recent edits across all blocks
+ */
+declare function getRecentEdits(langContent: LanguageContent, limit?: number): TextEdit[];
+/**
+ * Export changes for developer handoff
+ */
+declare function exportTextChanges(textContent: PageTextContent, language: string): TextChangesExport | null;
+/**
+ * Get available languages for a page's text content
+ */
+declare function getTextContentLanguages(textContent: PageTextContent | undefined): string[];
+/**
+ * Get language label for display
+ */
+declare function getLanguageLabel(code: string): string;
+/**
+ * Format relative time (e.g., "2 hours ago")
+ */
+declare function formatRelativeTime(dateString: string): string;
+
+/**
+ * Screenshot/scraping utility functions
+ * Pure functions only - no API calls
+ *
+ * Source: framed-app/src/services/screenshotService.ts (pure functions only)
+ */
+/**
+ * Convert URL to friendly page name (fallback when title can't be fetched)
+ * Example: https://example.com/about-us -> About Us
+ */
+declare function generatePageName(url: string): string;
+/**
+ * Parse sitemap XML and extract page URLs
+ * Note: Uses browser DOMParser API
+ */
+declare function parseSitemapXML(xmlText: string): string[];
+/**
+ * Generate minimal Phase 1 data for review-only projects
+ */
+declare function generateMinimalPhase1Data(businessName: string, pageNames: string[]): {
+    business_name: string;
+    industry: string;
+    goal: string;
+    audience: string;
+    is_ecommerce: boolean;
+    pages: string[];
+    custom_pages: string[];
+    page_content: {};
+    legal_content_preference: "not_sure";
+    has_logo: boolean;
+    logo_url: null;
+    colors: {
+        primary: null;
+        secondary: null;
+        accent: null;
+        no_idea: boolean;
+    };
+    font: {
+        primary: null;
+        secondary: null;
+        custom_fonts: never[];
+        no_idea: boolean;
+    };
+    style_keywords: never[];
+    references: never[];
+};
+
+/**
+ * SEO audit utility functions
+ * Pure functions for parsing and scoring - no API calls
+ *
+ * Source: framed-app/src/services/seoService.ts (pure functions only)
+ */
+
+/**
+ * Parse Apify SEO audit results into our format
+ */
+declare const parseApifyResults: (apifyResults: any[]) => SeoAuditResult[];
+/**
+ * Format issue title from camelCase key
+ */
+declare const formatIssueTitle: (key: string) => string;
+/**
+ * Calculate SEO scores based on issues
+ */
+declare const calculateScores: (issues: SeoAuditResult["issues"], rawData: any) => SeoAuditResult["scores"];
+
+/**
+ * Performance analysis utility functions
+ * Pure functions for parsing and formatting - no API calls
+ *
+ * Source: framed-app/src/services/performanceService.ts (pure functions only)
+ */
+
+interface PageSpeedResponse {
+    lighthouseResult: {
+        categories: {
+            performance: {
+                score: number;
+            };
+            accessibility: {
+                score: number;
+            };
+            'best-practices': {
+                score: number;
+            };
+            seo: {
+                score: number;
+            };
+        };
+        audits: Record<string, any>;
+        lighthouseVersion: string;
+    };
+    analysisUTCTimestamp: string;
+}
+/**
+ * Parse PageSpeed Insights response into our format
+ */
+declare const parsePageSpeedResponse: (data: PageSpeedResponse, url: string, strategy: "mobile" | "desktop") => PerformanceReport;
+/**
+ * Format milliseconds to human-readable time
+ */
+declare const formatMs: (ms: number) => string;
+/**
+ * Format bytes to human-readable size
+ */
+declare const formatBytes: (bytes: number) => string;
+/**
+ * Get color class based on score
+ */
+declare const getScoreColor: (score: number) => string;
+/**
+ * Get background color class based on score
+ */
+declare const getScoreBgColor: (score: number) => string;
+
+/**
+ * Generate instruction text for maintenance items
+ *
+ * Creates concise, AI-friendly instructions that can be copied to clipboard
+ * for use with tools like Claude, Cursor, etc.
+ */
+
+interface GenerateInstructionOptions {
+    item: MaintenanceItem & {
+        quote?: MaintenanceQuote;
+    };
+    projectName?: string;
+    liveUrl?: string;
+}
+/**
+ * Generate a short, copyable instruction for a maintenance item
+ */
+declare function generateItemInstruction({ item, projectName, liveUrl }: GenerateInstructionOptions): string;
+/**
+ * Generate instruction for a page comment (Phase 4)
+ */
+interface PageCommentLike {
+    comment: string;
+    resolved?: boolean;
+    element_text?: string;
+    element_type?: string;
+    user_name?: string;
+    screenshot_type?: string;
+    attachments?: unknown[];
+    metadata?: {
+        source?: string;
+        originalContent?: string;
+        newContent?: string;
+        cssSelector?: string;
+        pageUrl?: string;
+        pagePath?: string;
+    };
+}
+interface GenerateCommentInstructionOptions {
+    comment: PageCommentLike;
+    pageName?: string;
+    projectName?: string;
+    demoUrl?: string;
+}
+/**
+ * Generate a short, copyable instruction for a page comment (Phase 4)
+ */
+declare function generateCommentInstruction({ comment, pageName, projectName, demoUrl }: GenerateCommentInstructionOptions): string;
+
+export { type AIConfig, type AIConversation, type AIConversationTurn, type AIFeatureResult, type AIQuestion, type AIToolConfig, type AIToolType, type AdditionalContentItem, type AdditionalContentType, type Agency, type Annotation, type AnnotationBody, type AnnotationData, type AnnotationMode, type AnnotationTarget, type ApiBackendDetails, type ApiEndpointConfig, type ApiStyle, type AppScreenConfig, type ApplyResolutionOptions, type Assignment, type Attachment, type AttachmentTranscription, type AuthConfig, type AuthMode, type BaseFeedItem, type BranchingRule, type BuildSpecData, type BuildSpecExport, type BuildSpecItem, type BuildSpecItemStatus, type BuildSpecSection, type CTAInfo, type ChangelogCategory, type ChangelogEntry, type Comment, type CommentAttachment, type ContentBlock, type ContentSection, type CrawledElementType, type CrawledTextElement, type CreateCommentOptions, type CredentialType, DATE_PRESETS, type DataFieldDefinition, type DataModelDefinition, type DataModelReference, type DataRelationship, type DatePreset, type DateRange, type DependencyRule, type DiffPart, type DomainCheckStatus, type DomainMonitor, type ElementHierarchy, type ElementInfo, type ElementMetadata, type EnhancedEcommerceDetails, type EnhancedPromptResponse, type ExportFormat, type ExportedChange, type FAQ, FEATURE_DEFAULTS, FEATURE_DESCRIPTIONS, FEATURE_NAMES, type FeedFilters, type FeedItem, type FeedStats, type FeedStatusFilter, type FeedTypeFilter, type FeedbackComment, type FeedbackFeedItem, type FeedbackInfo, type FeedbackRound, type FeedbackRoundSummary, type FlowStep, FramedApiClient, type FramedApiError, type FramedConfig, type GeneralComment, type GenerateCommentInstructionOptions, type GenerateInstructionOptions, type GlobalElements, type GlobalsSubType, type GroupedFeedItems, type HourPackage, type HourPackageStatus, type ImageComment, type ImageFeedItem, type ImageStatus, type ImportedBlockData, type ImportedContentData, type ImportedImageData, type ImportedPageData, type ImportedSectionData, type ImprovementSuggestion, type InternalNote, LANGUAGE_LABELS, type LanguageContent, type LanguageSettings, type LayoutOption, type LimitStatus, type LocalizableString, type LocalizedContent, MODULES, MODULE_PHASES, MONITORING_FEATURE_DESCRIPTIONS, MONITORING_FEATURE_NAMES, type MaintenanceActivity, type MaintenanceCategory, type MaintenanceComment, type MaintenanceCycle, type MaintenanceCycleSummary, type MaintenanceItem, type MaintenanceItemExtended, type MaintenanceItemStatus, type MaintenancePriority, type MaintenanceQuote, type MaintenanceStats, type MediaInfo, type Mention, type MobileAppDetails, type MobilePlatform, type ModuleInfo, type ModuleLimits, type ModuleType, type ModuleUsageStats, type MonthlyReport, type MonthlyReportData, PAGE_LAYOUTS, PHASE_TO_MODULE, PLAN_LIMITS, type PageComment, type PageCommentLike, type PageContent, type PageDetail, type PageImage, type PageInfo, type PageTextContent, type PageTypeLayouts, type PageVersion, type ParsedResolutionItem, type PendingAttachment, type PerformanceAudit, type PerformanceMetrics, type PerformanceOpportunity, type PerformanceReport, type Phase1Data, type Phase2Data, type Phase2NavigationActions, type Phase2NavigationState, type Phase3Data, type Phase4Data, type Phase4Page, type Phase5Data, type Phase5NotificationType, type PlanConfiguration, type PlanTier, type PlanType, type Position, type PricingTier, type Project, type ProjectCategory, type ProjectCategoryInfo, type ProjectContext, type ProjectContextFile, type ProjectData, type ProjectFeature, type ProjectMember, type ProjectMonitoringFeatures, type ProjectOverview, type ProjectPerformanceUsage, type ProjectShare, type ProjectStatus, type ProjectType, type QuestionCategory, type QuestionOption, type QuestionType, type QuoteStatus, type RecurringConfig, type Reference, type ResolutionImportResult, type ResolutionParseResult, type ResolutionStatus, type SDKConfig, type SaasCategory, type SaasDetails, type ScreenDefinition, type ScreenType, type ScreenshotInfo, type Section, type SectionStatus, type SectionSuggestion, type SectionSuggestionStatus, type SectionTypeData, type SeoAuditIssue, type SeoAuditResult, type SeoReport, type Session, type Stat, type StatusTransition, type StoredCredential, type SubscriptionStatus, type SuggestedPage, type SuggestionCategory, type SuggestionImpact, type SuggestionStatus, type SyncConfig, type SyncResult, type Task, type TaskComment, type TaskInfo, type TaskMeta, type TaskStatus, type TaskType, type TextChangesExport, type TextEdit, type TextEditFeedItem, type TimeEntry, type TranslationResult, type UploadMediaOptions, type UploadMediaResult, type UploadResult, type UptimeCheck, type UptimeIncident, type UptimeMonitor, type UsageLimits, type User, type UserFlowConfig, type UserPreferences, type UserRole, type ValidationRule, type ViewportMode, type WebsitePageConfig, type WidgetConfig, type WidgetDataLayer, type WidgetFeatures, type WidgetSession, type WidgetSessionCreate, type WidgetSessionValidation, type WidgetUIState, type WizardCallbacks, addLanguageContent, agencyHasMonitoringFeature, applyBlockEdit, applyListEdit, applyResolutions, calculateFeedStats, calculateRoundSummary, calculateScores, canAccessPhase, canApproveSuggestion, canConfigureModules, canCreateAgency, canCreateProject, canDeleteAgency, canDeleteProject, canDisablePhase, canEditProject, canInviteUsers, canLockPhase, canManageAgency, canManageProjectMembers, canManageTeam, canRemoveUser, canSetProjectLimit, canSubmitFeedback, canUnlockSoftLock, canUseAI, canViewProject, collectFeedItems, collectProjectMedia, computeTextDiff, countRoundStats, createComment, createEmptyLocalizedContent, createWizardCallbacks, deleteMedia, ensureLocalizedContent, exportTextChanges, extractMentions, filterFeedItems, formatBytes, formatDateRangeLabel, formatFileSize, formatIssueTitle, formatMentions, formatMs, formatRelativeTime, formatSubscriptionDate, generateCommentInstruction, generateItemInstruction, generateJSONExport, generateMinimalPhase1Data, generateNaturalLanguagePrompt, generatePageName, generatePlanningSection, generateProjectInstructionsMd, generateShortPrompt, getAccessiblePhases, getAllFeedbackIds, getAllProjectCategories, getAvailableFeatures, getAvailableLanguages, getAvailablePages, getBlockHistory, getCustomPages, getDaysRemaining, getDefaultModules, getDefaultPageName, getDefaultScreenType, getDisplayValue, getEffectiveProjectLimit, getEmptyDateRange, getFeaturesForTier, getFirstAccessiblePhase, getFirstVisiblePhase, getLanguageLabel, getLanguageSettings, getLayoutsForPage, getLocalizedValue, getModifiedCount, getModuleDescription, getModuleDisplayName, getModuleLimits, getModulePhasesLabel, getPageDisplayName, getPageStatus, getPages, getPlanBadgeColor, getPlanDisplayName, getProjectCategory, getProjectCategoryInfo, getRecentEdits, getRoleBadge, getRoleBadgeColor, getRoleDisplayName, getScoreBgColor, getScoreColor, getScreenDisplayName, getScreenTypeLabel, getScreens, getScreenshotUrl, getSectionStatus, getSeoCreditsInfo, getSubscriptionStatusBadgeColor, getSubscriptionStatusDisplayName, getTextContentLanguages, getTotalBlockCount, getUserSupabase, getVisiblePhases, groupFeedItemsByPage, hasAIContentGeneration, hasAdminPrivileges, hasEqualOrHigherRole, hasFeature, hasHigherRole, hasPerformanceAnalysis, hasRole, hasSeoAudit, initUserSupabase, isAdmin, isBlockModified, isClient, isDateRangeActive, isDefaultPage, isEcommerceProject, isFeedbackItem, isImageFeedItem, isLocalizedContent, isLocalizedFieldComplete, isManager, isModuleAvailable, isModuleEnabled, isModuleUnlimited, isModuleVisible, isPhaseAccessible, isPhaseDisabled, isPhaseVisible, isSoftLocked, isSubscriptionValid, isSupabaseInitialized, isSuperAdmin, isTextEditItem, isWebsiteBasedProject, isWithinDateRange, mergeFeatures, migratePhase1Data, migrateToLocalized, migrateToRounds, needsMigration, normalizeLocalizedField, parseApifyResults, parsePageSpeedResponse, parseResolutionReport, parseSitemapXML, projectHasMonitoringFeature, resetUserSupabase, restoreBlockToOriginal, shouldShowTraditionalWizard, str, toLocalizedContent, translateContent, updateLocalizedValue, uploadFile, uploadFont, uploadLogo, uploadMedia, useTranslation };