@duongthiu/onex-core 0.1.0

package/dist/api-vuL1Eg5L.d.ts

@@ -0,0 +1,2961 @@
+import React$1 from 'react';
+
+/**
+ * Base Entity Interface
+ * Common fields for all entities in the system
+ * All entities should extend this for consistency
+ */
+interface BaseEntity {
+    /** Unique identifier */
+    id: string;
+    /** Creation timestamp (ISO 8601) */
+    createdAt?: string;
+    /** Last update timestamp (ISO 8601) */
+    updatedAt?: string;
+}
+
+/**
+ * Website Settings Types
+ * Type definitions for dynamic website settings including social connections,
+ * hotline connections, tracking analytics, and contact information.
+ */
+/**
+ * Icon definition for various settings items
+ */
+interface SettingsIcon {
+    /** Icon filename */
+    name: string;
+    /** Icon URL or data URI */
+    url: string;
+}
+/**
+ * Social media platform types
+ */
+type SocialPlatform = "facebook" | "instagram" | "tiktok" | "linkedin" | "zalo" | "discord" | "github" | "twitter" | "youtube" | "pinterest" | string;
+/**
+ * Social media connection configuration
+ */
+interface SocialConnection {
+    /** Unique identifier for this social connection */
+    id: string;
+    /** Display name of the platform */
+    name: string;
+    /** Platform icon */
+    icon: SettingsIcon;
+    /** URL link to the social media profile */
+    link: string;
+    /** Platform identifier */
+    platform: SocialPlatform;
+    /** Whether this connection is enabled and should be displayed */
+    enabled: boolean;
+    /** Display order (lower numbers appear first) */
+    order: string;
+}
+/**
+ * Hotline connection types
+ */
+type HotlineType = "phone" | "email" | "whatsapp" | "telegram" | string;
+/**
+ * Hotline contact configuration
+ */
+interface HotlineConnection {
+    /** Unique identifier for this hotline */
+    id: string;
+    /** Display name of the contact method */
+    name: string;
+    /** Contact method icon */
+    icon: SettingsIcon;
+    /** Type of contact method */
+    type: HotlineType;
+    /** Contact value (phone number, email address, etc.) */
+    value: string;
+    /** Whether this hotline is enabled */
+    enabled: boolean;
+    /** Display order */
+    order: string;
+}
+/**
+ * Analytics tracking platform types
+ */
+type TrackingPlatform = "google_analytics" | "meta_pixel" | "google_tag_manager" | "tiktok_pixel" | string;
+/**
+ * Tracking analytics configuration
+ */
+interface TrackingAnalytics {
+    /** Unique identifier for this tracking integration */
+    id: string;
+    /** Display name of the analytics platform */
+    name: string;
+    /** Platform icon */
+    icon: SettingsIcon;
+    /** Platform identifier */
+    platform: TrackingPlatform;
+    /** Tracking/Measurement ID */
+    tracking_id: string;
+    /** Whether this tracking is enabled */
+    enabled: boolean;
+    /** Display order */
+    order: string;
+}
+/**
+ * Contact email configuration
+ */
+interface ContactEmail {
+    /** Email address for contact */
+    email: string;
+    /** Whether contact email is enabled */
+    enabled: boolean;
+}
+/**
+ * Company information configuration
+ */
+interface CompanyInfo {
+    /** Company name */
+    name: string;
+    /** Company tagline/slogan */
+    tagline?: string;
+    /** Company description */
+    description?: string;
+    /** Company logo URL */
+    logo_url?: string;
+    /** Theme ID for this company */
+    themeId?: string;
+}
+/**
+ * Complete website settings structure
+ */
+interface WebsiteSettings {
+    /** Social media connection configurations */
+    social_connections?: SocialConnection[];
+    /** Hotline contact configurations */
+    hotline_connections?: HotlineConnection[];
+    /** Tracking analytics configurations */
+    tracking_analytics?: TrackingAnalytics[];
+    /** Contact email configuration */
+    contact_email?: ContactEmail;
+    /** Company information */
+    company_info?: CompanyInfo;
+    /** Additional dynamic settings */
+    [key: string]: unknown;
+}
+/**
+ * Helper type to get only enabled items from an array
+ */
+type EnabledItems<T extends {
+    enabled: boolean;
+}> = T[];
+/**
+ * Sorted and filtered social connections (enabled only)
+ */
+type ActiveSocialConnections = SocialConnection[];
+/**
+ * Sorted and filtered hotline connections (enabled only)
+ */
+type ActiveHotlineConnections = HotlineConnection[];
+/**
+ * Sorted and filtered tracking analytics (enabled only)
+ */
+type ActiveTrackingAnalytics = TrackingAnalytics[];
+
+/**
+ * Field Definition Types
+ * Used for defining customizable settings in sections, blocks, and themes
+ */
+
+/**
+ * Field types - all available field types for component settings
+ */
+declare const FIELD_TYPES: {
+    readonly TEXT: "text";
+    readonly TEXTAREA: "textarea";
+    readonly NUMBER: "number";
+    readonly CHECKBOX: "checkbox";
+    readonly BOOLEAN: "boolean";
+    readonly SELECT: "select";
+    readonly RADIO: "radio";
+    readonly RANGE: "range";
+    readonly URL: "url";
+    readonly RICHTEXT: "richtext";
+    readonly COLOR: "color";
+    readonly COLOR_BACKGROUND: "color_background";
+    readonly IMAGE: "image";
+    readonly IMAGE_PICKER: "image_picker";
+    readonly VIDEO: "video";
+    readonly VIDEO_URL: "video_url";
+    readonly FONT: "font";
+    readonly FONT_PICKER: "font_picker";
+    readonly INLINE_RICHTEXT: "inline_richtext";
+    readonly TEXT_ALIGNMENT: "text_alignment";
+    readonly HTML: "html";
+    readonly ARRAY: "array";
+    readonly REPEATER: "repeater";
+    readonly COLLECTION: "collection";
+    readonly PRODUCT: "product";
+    readonly BLOG: "blog";
+    readonly ARTICLE: "article";
+    readonly PAGE: "page";
+};
+type FieldType = (typeof FIELD_TYPES)[keyof typeof FIELD_TYPES];
+interface BaseFieldDefinition {
+    /** Unique identifier for the field */
+    id: string;
+    /** Field type */
+    type: FieldType;
+    /** Display label */
+    label: string;
+    /** Help text or description */
+    info?: string;
+    /** Whether the field is required */
+    required?: boolean;
+    /** Placeholder text */
+    placeholder?: string;
+}
+interface TextFieldDefinition extends BaseFieldDefinition {
+    type: "text";
+    default?: string;
+    maxLength?: number;
+}
+interface TextareaFieldDefinition extends BaseFieldDefinition {
+    type: "textarea";
+    default?: string;
+    maxLength?: number;
+    rows?: number;
+}
+interface NumberFieldDefinition extends BaseFieldDefinition {
+    type: "number";
+    default?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    unit?: string;
+}
+interface RangeFieldDefinition extends BaseFieldDefinition {
+    type: "range";
+    default?: number;
+    min: number;
+    max: number;
+    step?: number;
+    unit?: string;
+}
+interface ColorFieldDefinition extends BaseFieldDefinition {
+    type: "color";
+    default?: string;
+}
+interface ImageFieldDefinition extends BaseFieldDefinition {
+    type: "image";
+    default?: string;
+    accept?: string[];
+}
+interface SelectFieldDefinition extends BaseFieldDefinition {
+    type: "select";
+    default?: string;
+    options: Array<{
+        label: string;
+        value: string;
+    }>;
+}
+interface CheckboxFieldDefinition extends BaseFieldDefinition {
+    type: "checkbox";
+    default?: boolean;
+}
+interface BooleanFieldDefinition extends BaseFieldDefinition {
+    type: "boolean";
+    default?: boolean;
+}
+interface RadioFieldDefinition extends BaseFieldDefinition {
+    type: "radio";
+    default?: string;
+    options: Array<{
+        label: string;
+        value: string;
+    }>;
+}
+interface UrlFieldDefinition extends BaseFieldDefinition {
+    type: "url";
+    default?: string;
+}
+interface RichTextFieldDefinition extends BaseFieldDefinition {
+    type: "richtext";
+    default?: string;
+}
+interface VideoFieldDefinition extends BaseFieldDefinition {
+    type: "video";
+    default?: string;
+    accept?: string[];
+}
+interface FontFieldDefinition extends BaseFieldDefinition {
+    type: "font";
+    default?: string;
+}
+interface ArrayFieldDefinition extends BaseFieldDefinition {
+    type: "array";
+    default?: unknown[];
+    itemSchema?: Record<string, unknown>;
+}
+interface CollectionFieldDefinition extends BaseFieldDefinition {
+    type: "collection";
+    default?: string;
+}
+interface ProductFieldDefinition extends BaseFieldDefinition {
+    type: "product";
+    default?: string;
+}
+interface BlogFieldDefinition extends BaseFieldDefinition {
+    type: "blog";
+    default?: string;
+}
+interface ArticleFieldDefinition extends BaseFieldDefinition {
+    type: "article";
+    default?: string;
+}
+interface PageFieldDefinition extends BaseFieldDefinition {
+    type: "page";
+    default?: string;
+}
+interface RepeaterFieldDefinition extends BaseFieldDefinition {
+    type: "repeater";
+    default?: unknown[];
+    itemFields?: FieldDefinition[];
+}
+interface TextAlignmentFieldDefinition extends BaseFieldDefinition {
+    type: "text_alignment";
+    default?: "left" | "center" | "right";
+}
+interface InlineRichTextFieldDefinition extends BaseFieldDefinition {
+    type: "inline_richtext";
+    default?: string;
+    maxLength?: number;
+}
+interface VideoUrlFieldDefinition extends BaseFieldDefinition {
+    type: "video_url";
+    default?: string;
+    accept?: ("youtube" | "vimeo")[];
+}
+interface HtmlFieldDefinition extends BaseFieldDefinition {
+    type: "html";
+    default?: string;
+}
+interface ColorBackgroundFieldDefinition extends BaseFieldDefinition {
+    type: "color_background";
+    default?: string;
+    supportsGradient?: boolean;
+}
+interface FontPickerFieldDefinition extends BaseFieldDefinition {
+    type: "font_picker";
+    default?: string;
+}
+interface ImagePickerFieldDefinition extends BaseFieldDefinition {
+    type: "image_picker";
+    default?: string;
+    accept?: string[];
+}
+/**
+ * Union type of all field definitions
+ */
+type FieldDefinition = TextFieldDefinition | TextareaFieldDefinition | NumberFieldDefinition | RangeFieldDefinition | ColorFieldDefinition | ImageFieldDefinition | SelectFieldDefinition | CheckboxFieldDefinition | BooleanFieldDefinition | RadioFieldDefinition | UrlFieldDefinition | RichTextFieldDefinition | VideoFieldDefinition | FontFieldDefinition | ArrayFieldDefinition | RepeaterFieldDefinition | CollectionFieldDefinition | ProductFieldDefinition | BlogFieldDefinition | ArticleFieldDefinition | PageFieldDefinition | TextAlignmentFieldDefinition | InlineRichTextFieldDefinition | VideoUrlFieldDefinition | HtmlFieldDefinition | ColorBackgroundFieldDefinition | FontPickerFieldDefinition | ImagePickerFieldDefinition;
+/**
+ * Setting Value Types
+ */
+type SettingValue = string | number | boolean | string[] | unknown[] | undefined;
+/**
+ * Settings object - maps field IDs to their values
+ * Extended with WebsiteSettings for dynamic website configuration
+ */
+interface Settings extends WebsiteSettings {
+    [key: string]: SettingValue | unknown;
+}
+
+/**
+ * Animation Type Definitions
+ * Defines animation settings for components
+ */
+
+/**
+ * Animation Types
+ */
+type AnimationType = "fadeIn" | "fadeInUp" | "fadeInDown" | "fadeInLeft" | "fadeInRight" | "slideInUp" | "slideInDown" | "slideInLeft" | "slideInRight" | "scaleIn" | "scaleInUp" | "rotate" | "rotateIn" | "bounce" | "pulse" | "shake" | "flip" | "none";
+/**
+ * Animation Easing Functions
+ */
+type AnimationEasing = "linear" | "easeIn" | "easeOut" | "easeInOut" | "easeInBack" | "easeOutBack" | "easeInOutBack" | "easeInElastic" | "easeOutElastic" | "easeInOutElastic";
+/**
+ * Animation Trigger
+ */
+type AnimationTrigger = "onLoad" | "onScroll" | "onHover" | "onClick";
+/**
+ * Animation Settings
+ */
+interface AnimationSettings {
+    /** Animation type */
+    type: AnimationType;
+    /** Duration in seconds */
+    duration: number;
+    /** Delay in seconds */
+    delay: number;
+    /** Easing function */
+    easing: AnimationEasing;
+    /** When to trigger the animation */
+    trigger?: AnimationTrigger;
+    /** Repeat infinitely */
+    infinite?: boolean;
+    /** Number of iterations (if not infinite) */
+    iterations?: number;
+    /** Stagger animation for child elements */
+    stagger?: boolean;
+    /** Stagger delay between children (seconds) */
+    staggerDelay?: number;
+}
+/**
+ * Animation Field Definitions
+ * Use these in component schemas to add animation settings
+ */
+declare const animationFieldDefinitions: FieldDefinition[];
+/**
+ * Default animation settings
+ */
+declare const defaultAnimationSettings: AnimationSettings;
+
+/**
+ * Component Type Definitions
+ * Types for the component registry system
+ */
+
+/**
+ * Responsive breakpoints
+ */
+type Breakpoint = "mobile" | "tablet" | "desktop";
+/**
+ * Style Settings
+ * Supports basic and advanced CSS properties
+ */
+interface StyleSettings {
+    margin?: string;
+    marginTop?: string;
+    marginRight?: string;
+    marginBottom?: string;
+    marginLeft?: string;
+    padding?: string;
+    paddingTop?: string;
+    paddingRight?: string;
+    paddingBottom?: string;
+    paddingLeft?: string;
+    width?: string;
+    height?: string;
+    maxWidth?: string;
+    minWidth?: string;
+    minHeight?: string;
+    backgroundColor?: string;
+    color?: string;
+    borderColor?: string;
+    fontSize?: string;
+    fontWeight?: string;
+    lineHeight?: string;
+    textAlign?: "left" | "center" | "right" | "justify";
+    letterSpacing?: string;
+    textTransform?: string;
+    borderWidth?: string;
+    borderRadius?: string;
+    borderStyle?: "solid" | "dashed" | "dotted" | "none";
+    display?: string;
+    flexDirection?: string;
+    justifyContent?: string;
+    alignItems?: string;
+    gap?: string;
+    gridTemplateColumns?: string;
+    gridTemplateRows?: string;
+    position?: string;
+    top?: string;
+    right?: string;
+    bottom?: string;
+    left?: string;
+    zIndex?: string;
+    opacity?: string;
+    transform?: string;
+    transition?: string;
+    boxShadow?: string;
+    cursor?: string;
+    overflow?: string;
+    objectFit?: string;
+    aspectRatio?: string;
+    customClasses?: string;
+    [key: string]: SettingValue;
+}
+/**
+ * Responsive style settings
+ */
+interface ResponsiveStyles {
+    mobile?: Partial<StyleSettings>;
+    tablet?: Partial<StyleSettings>;
+    desktop?: Partial<StyleSettings>;
+}
+/**
+ * Component Definition - Blueprint for a component type
+ */
+interface ComponentDefinition {
+    /** Unique type identifier (e.g., 'heading', 'button') */
+    type: ComponentType;
+    /** Display name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Icon identifier */
+    icon?: string;
+    /** Category (text, media, interactive, layout) */
+    category: ComponentCategory;
+    /** Content settings (text, url, etc.) */
+    contentSettings: FieldDefinition[];
+    /** Style settings - Basic styles shown by default */
+    basicStyleSettings: FieldDefinition[];
+    /** Advanced style settings - Shown when user toggles advanced mode */
+    advancedStyleSettings: FieldDefinition[];
+    /** Default content values */
+    contentDefaults: Settings;
+    /** Default style values */
+    styleDefaults: StyleSettings;
+    /** Whether this component supports responsive styles */
+    supportsResponsive: boolean;
+    /** Tags for search */
+    tags?: string[];
+}
+/**
+ * Component Instance - Actual component in a section
+ */
+interface ComponentInstance extends BaseEntity {
+    /** Component type reference */
+    type: ComponentType;
+    /** Content settings (text, url, image src, etc.) */
+    content: Settings;
+    /** Style settings */
+    style: StyleSettings;
+    /** Style mode - basic uses presets, advanced uses custom values */
+    styleMode?: "basic" | "advanced";
+    /** Responsive style overrides */
+    responsiveStyle?: ResponsiveStyles;
+    /** Display order */
+    order: number;
+    /** Whether enabled */
+    enabled?: boolean;
+}
+/**
+ * Component Registration - Runtime info
+ */
+interface ComponentRegistration {
+    /** Component definition */
+    definition: ComponentDefinition;
+    /** React component */
+    component: React.ComponentType<ComponentProps>;
+    /** Registration timestamp */
+    registeredAt: Date;
+    /** Category */
+    category: ComponentCategory;
+    /** Tags */
+    tags: string[];
+}
+/**
+ * Props passed to component React components
+ */
+interface ComponentProps {
+    /** Component instance data */
+    component: ComponentInstance;
+    /** Component definition */
+    definition: ComponentDefinition;
+    /** Section ID (for component detection) */
+    sectionId?: string;
+    /** Whether in edit mode */
+    isEditing?: boolean;
+    /** Additional data (e.g., website settings) */
+    data?: Record<string, unknown>;
+    /** Callback when content changes */
+    onContentChange?: (content: Settings) => void;
+    /** Callback when style changes */
+    onStyleChange?: (style: StyleSettings, breakpoint?: Breakpoint) => void;
+    /** Callback when component should be removed */
+    onRemove?: () => void;
+    /** Additional classes */
+    className?: string;
+    /** Children for container components */
+    children?: React.ReactNode;
+}
+/**
+ * Component categories
+ */
+declare const COMPONENT_CATEGORIES: {
+    readonly TEXT: "text";
+    readonly MEDIA: "media";
+    readonly INTERACTIVE: "interactive";
+    readonly FORM: "form";
+    readonly LAYOUT: "layout";
+    readonly ADVANCED: "advanced";
+};
+type ComponentCategory = (typeof COMPONENT_CATEGORIES)[keyof typeof COMPONENT_CATEGORIES];
+/**
+ * Component types - all available component types
+ */
+declare const COMPONENT_TYPES: {
+    readonly INPUT: "input";
+    readonly TEXTAREA: "textarea";
+    readonly SELECT: "select";
+    readonly CHECKBOX: "checkbox";
+    readonly HEADING: "heading";
+    readonly PARAGRAPH: "paragraph";
+    readonly QUOTE: "quote";
+    readonly BADGE: "badge";
+    readonly COMPANY_INFO: "company-info";
+    readonly IMAGE: "image";
+    readonly VIDEO: "video";
+    readonly ICON: "icon";
+    readonly GALLERY: "gallery";
+    readonly BUTTON: "button";
+    readonly LINK: "link";
+    readonly RATING: "rating";
+    readonly SOCIAL_LINKS: "social-links";
+    readonly HOTLINE_CONTACTS: "hotline-contacts";
+    readonly GRID: "grid";
+    readonly COLUMNS: "columns";
+    readonly CARD: "card";
+    readonly CONTAINER: "container";
+    readonly DIVIDER: "divider";
+    readonly SPACER: "spacer";
+    readonly MAP: "map";
+    readonly PROGRESS: "progress";
+    readonly ALERT: "alert";
+    readonly CODE: "code";
+    readonly TIMER: "timer";
+    readonly ACCORDION: "accordion";
+    readonly TABS: "tabs";
+    readonly TABLE: "table";
+    readonly LIST: "list";
+    readonly FEATURE_CARD: "feature-card";
+    readonly PRODUCT_CARD: "product-card";
+    readonly BLOG_CARD: "blog-card";
+};
+type ComponentType = (typeof COMPONENT_TYPES)[keyof typeof COMPONENT_TYPES];
+/**
+ * Apply scope - when changing component settings
+ */
+type ApplyScope = "instance" | "all";
+/**
+ * Apply scope dialog result
+ */
+interface ApplyScopeResult {
+    scope: ApplyScope;
+    componentType: ComponentType;
+}
+
+/**
+ * Block Type Definitions
+ * Blocks are repeatable content units within sections
+ */
+
+/**
+ * Block Definition - Schema for a type of block
+ */
+interface BlockDefinition {
+    /** Unique type identifier (e.g., "testimonial-item") */
+    type: string;
+    /** Display name */
+    name: string;
+    /** Description of the block */
+    description?: string;
+    /** Icon identifier for UI */
+    icon?: string;
+    /** Category for organization */
+    category?: string;
+    /** Customizable settings */
+    settings: FieldDefinition[];
+    /** Default settings values */
+    defaults: Settings;
+    /** Maximum number of instances allowed in a section */
+    limit?: number;
+    /** Minimum number of instances required */
+    min?: number;
+    /** Whether this block type can be reordered */
+    sortable?: boolean;
+    /** Theme ID if this is a theme-specific block (undefined = shared) */
+    themeId?: string;
+    /** If true, this block overrides a shared block */
+    inherited?: boolean;
+    /** Reference to base block type if this is an override */
+    baseType?: string;
+}
+/**
+ * Data source types for blocks
+ */
+type BlockDataSourceType = "manual" | "api" | "query" | "parent";
+/**
+ * Data source configuration for blocks
+ * Enables blocks to fetch data from various sources
+ */
+interface BlockDataSource {
+    /** Type of data source */
+    type: BlockDataSourceType;
+    /** API endpoint (e.g., "/api/products") */
+    endpoint?: string;
+    /** HTTP method */
+    method?: "GET" | "POST";
+    /** Query parameters or request body */
+    params?: Record<string, unknown>;
+    /** Custom headers */
+    headers?: Record<string, string>;
+    /** Collection/table name */
+    collection?: string;
+    /** Filter criteria */
+    filter?: object;
+    /** Sort order */
+    sort?: object;
+    /** Result limit */
+    limit?: number;
+    /** Key to read from parent block/section */
+    parentKey?: string;
+    /** Function name to transform fetched data */
+    transform?: string;
+    /** Cache configuration */
+    cache?: {
+        enabled: boolean;
+        duration: number;
+        key?: string;
+    };
+}
+/**
+ * Block Instance - Actual block data in a section
+ * Supports recursive nesting: blocks can contain components AND other blocks
+ * Supports API data sources for dynamic content
+ */
+interface BlockInstance extends BaseEntity {
+    /** Block type reference */
+    type: string;
+    /** Current settings values */
+    settings?: Settings;
+    /** Block content (alternative to settings) */
+    content?: Record<string, unknown>;
+    /** Display order */
+    order: number;
+    /** Whether the block is currently enabled/visible */
+    enabled?: boolean;
+    /** Custom name for this instance (optional) */
+    customName?: string;
+    /** Custom style */
+    style?: Record<string, unknown>;
+    /** Animation settings */
+    animation?: Record<string, unknown>;
+    /** Optional theme context for this block instance */
+    themeContext?: string;
+    /** Data source configuration (manual, API, query, etc.) */
+    dataSource?: BlockDataSource;
+    /** Runtime data populated from data source (server-side) */
+    data?: Record<string, unknown>;
+    /** Loading state (for async data fetching) */
+    loading?: boolean;
+    /** Error state */
+    error?: string | null;
+    /** Components within this block */
+    components?: ComponentInstance[];
+    /** Nested blocks within this block (recursive!) */
+    blocks?: BlockInstance[];
+}
+/**
+ * Block Registration - Runtime registration info
+ */
+interface BlockRegistration {
+    /** Block definition */
+    definition: BlockDefinition;
+    /** React component for rendering */
+    component: React.ComponentType<BlockComponentProps>;
+    /** Registration timestamp */
+    registeredAt: Date;
+    /** Tags for searching/filtering */
+    tags?: string[];
+}
+/**
+ * Props passed to block components
+ */
+interface BlockComponentProps {
+    /** Block instance data */
+    block: BlockInstance;
+    /** Block definition */
+    definition: BlockDefinition;
+    /** Whether in edit mode */
+    isEditing?: boolean;
+    /** Section ID for nested block detection */
+    sectionId?: string;
+    /** Additional data (e.g., website settings) */
+    data?: Record<string, unknown>;
+    /** Callback when settings change */
+    onSettingsChange?: (settings: Settings) => void;
+    /** Callback when block is removed */
+    onRemove?: () => void;
+    /** Additional class names */
+    className?: string;
+}
+
+/**
+ * Section Type Definitions
+ * Sections are the main building blocks of pages
+ */
+
+/**
+ * Template Definition - A variant layout for a section type
+ */
+interface TemplateDefinition {
+    /** Unique template identifier (e.g., "default", "minimal", "split") */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Description of this template variant */
+    description?: string;
+    /** Preview image URL */
+    preview?: string;
+    /** Template-specific settings (overrides section settings) */
+    settings?: FieldDefinition[];
+    /** Default settings for this template */
+    defaults?: Settings;
+    /** Whether this is the default template */
+    isDefault?: boolean;
+}
+/**
+ * Section Schema - Blueprint for a section type
+ */
+interface SectionSchema {
+    /** Unique section type identifier (e.g., "hero", "features") */
+    type: string;
+    /** Display name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Category for organization (e.g., "headers", "content", "footers") */
+    category: string;
+    /** Icon identifier for UI */
+    icon?: string;
+    /** Available templates for this section */
+    templates: TemplateDefinition[];
+    /** Base settings (applied to all templates) */
+    settings: FieldDefinition[];
+    /** Default settings values */
+    defaults: Settings;
+    /** Block types that can be added to this section */
+    blocks?: BlockDefinition[];
+    /** Maximum number of blocks allowed */
+    maxBlocks?: number;
+    /** Whether blocks are sortable */
+    sortableBlocks?: boolean;
+    /** Whether this section is a global section (e.g., header, footer) */
+    global?: boolean;
+    /** Tags for searching/filtering */
+    tags?: string[];
+    /** Whether this section can be disabled */
+    disableable?: boolean;
+}
+/**
+ * Component Instance - Individual UI element with own settings
+ * Simplified version for sections - uses single settings object
+ * For detailed component instances, see ComponentInstance in component.ts
+ */
+interface SectionComponentInstance extends BaseEntity {
+    /** Component type (e.g., "heading", "button", "image") */
+    type: string;
+    /** Component settings values (legacy - prefer content/style split) */
+    settings?: Settings;
+    /** Content settings (text, url, image src, etc.) */
+    content?: Settings;
+    /** Style settings */
+    style?: Settings;
+    /** Style mode - basic uses presets, advanced uses custom values */
+    styleMode?: "basic" | "advanced";
+    /** Display order in the section */
+    order: number;
+    /** Whether the component is enabled/visible */
+    enabled?: boolean;
+}
+/**
+ * Section Instance - Actual section data in a page
+ */
+interface SectionInstance extends BaseEntity {
+    /** Section type reference */
+    type: string;
+    /** Selected template ID */
+    template: string;
+    /** Custom name for this instance */
+    name?: string;
+    /** Current settings values */
+    settings: Settings;
+    /** Component instances in this section (individual UI elements) */
+    components?: SectionComponentInstance[];
+    /** Block instances in this section */
+    blocks?: BlockInstance[];
+    /** Display order on the page */
+    order: number;
+    /** Whether the section is enabled/visible */
+    enabled?: boolean;
+}
+/**
+ * Section Registration - Runtime registration info
+ */
+interface SectionRegistration<TProps = SectionComponentProps> {
+    /** Section schema */
+    schema: SectionSchema;
+    /** Base component (may be overridden by template) */
+    component: React.ComponentType<TProps>;
+    /** Template-specific components */
+    templateComponents: Map<string, React.ComponentType<SectionComponentProps>>;
+    /** Registration timestamp */
+    registeredAt: Date;
+    /** Category */
+    category: string;
+    /** Tags for searching */
+    tags: string[];
+    /** Lazy load function */
+    lazyLoad?: () => Promise<React.ComponentType<TProps>>;
+}
+/**
+ * Props passed to section components
+ */
+interface SectionComponentProps {
+    /** Section instance data */
+    section: SectionInstance;
+    /** Section schema */
+    schema: SectionSchema;
+    /** Selected template definition */
+    template: TemplateDefinition;
+    /** Whether in edit mode */
+    isEditing?: boolean;
+    /** Optional data for sections (e.g., API data in view mode) */
+    data?: Record<string, unknown>;
+    /** Callback when settings change */
+    onSettingsChange?: (settings: Settings) => void;
+    /** Callback when component is added */
+    onComponentAdd?: (componentType: string) => void;
+    /** Callback when component is updated */
+    onComponentUpdate?: (componentId: string, updates: Partial<SectionComponentInstance>) => void;
+    /** Callback when component is removed */
+    onComponentRemove?: (componentId: string) => void;
+    /** Callback when components are reordered */
+    onComponentsReorder?: (componentIds: string[]) => void;
+    /** Callback when block is added */
+    onBlockAdd?: (blockType: string) => void;
+    /** Callback when block is updated */
+    onBlockUpdate?: (blockId: string, settings: Settings) => void;
+    /** Callback when block is removed */
+    onBlockRemove?: (blockId: string) => void;
+    /** Callback when blocks are reordered */
+    onBlocksReorder?: (blockIds: string[]) => void;
+    /** Additional class names */
+    className?: string;
+}
+/**
+ * Section category definitions
+ */
+declare const SECTION_CATEGORIES: {
+    readonly HEADER: "header";
+    readonly HERO: "hero";
+    readonly CONTENT: "content";
+    readonly FEATURES: "features";
+    readonly TESTIMONIALS: "testimonials";
+    readonly CTA: "cta";
+    readonly GALLERY: "gallery";
+    readonly PRICING: "pricing";
+    readonly FAQ: "faq";
+    readonly TEAM: "team";
+    readonly CONTACT: "contact";
+    readonly FOOTER: "footer";
+};
+type SectionCategory = (typeof SECTION_CATEGORIES)[keyof typeof SECTION_CATEGORIES];
+
+/**
+ * Theme Type Definitions
+ * Themes define the global design system and styling
+ */
+
+/**
+ * Design Token - Single design value (color, spacing, etc.)
+ */
+interface DesignToken {
+    /** Token name (e.g., "primary", "spacing-md") */
+    name: string;
+    /** Token value (e.g., "#3b82f6", "1rem") */
+    value: string;
+    /** CSS variable name (e.g., "--color-primary") */
+    variable: string;
+    /** Description */
+    description?: string;
+    /** Category for organization */
+    category: string;
+}
+/**
+ * Color Palette
+ */
+interface ColorPalette {
+    /** Primary brand color */
+    primary: string;
+    /** Secondary brand color */
+    secondary?: string;
+    /** Accent color */
+    accent?: string;
+    /** Background color */
+    background: string;
+    /** Foreground/text color */
+    foreground: string;
+    /** Muted background color */
+    muted: string;
+    /** Muted foreground color */
+    mutedForeground: string;
+    /** Card background color */
+    card: string;
+    /** Card foreground color */
+    cardForeground: string;
+    /** Popover background color */
+    popover: string;
+    /** Popover foreground color */
+    popoverForeground: string;
+    /** Border color */
+    border: string;
+    /** Input border color */
+    input: string;
+    /** Ring color (focus outlines) */
+    ring: string;
+    /** Success color */
+    success?: string;
+    /** Warning color */
+    warning?: string;
+    /** Error/destructive color */
+    destructive?: string;
+    /** Info color */
+    info?: string;
+}
+/**
+ * Typography Settings
+ */
+interface Typography {
+    /** Font family for headings */
+    fontFamily: {
+        heading: string;
+        body: string;
+        mono?: string;
+    };
+    /** Font sizes */
+    fontSize: {
+        xs: string;
+        sm: string;
+        base: string;
+        lg: string;
+        xl: string;
+        "2xl": string;
+        "3xl": string;
+        "4xl": string;
+        "5xl": string;
+    };
+    /** Font weights */
+    fontWeight: {
+        normal: number;
+        medium: number;
+        semibold: number;
+        bold: number;
+    };
+    /** Line heights */
+    lineHeight: {
+        tight: number;
+        normal: number;
+        relaxed: number;
+    };
+    /** Letter spacing */
+    letterSpacing?: {
+        tight: string;
+        normal: string;
+        wide: string;
+    };
+}
+/**
+ * Spacing Scale
+ */
+interface Spacing {
+    xs: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    "2xl": string;
+    "3xl": string;
+    "4xl": string;
+}
+/**
+ * Border Radius Scale
+ */
+interface BorderRadius {
+    none: string;
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    "2xl": string;
+    full: string;
+}
+/**
+ * Breakpoints for responsive design
+ */
+interface Breakpoints {
+    sm: string;
+    md: string;
+    lg: string;
+    xl: string;
+    "2xl": string;
+}
+/**
+ * Theme Configuration
+ */
+interface ThemeConfig {
+    /** Unique theme identifier */
+    id: string;
+    /** Theme name */
+    name: string;
+    /** Theme description */
+    description?: string;
+    /** Theme version */
+    version: string;
+    /** Theme author */
+    author?: string;
+    /** Color palette */
+    colors: {
+        light: ColorPalette;
+        dark?: ColorPalette;
+    };
+    /** Typography settings */
+    typography: Typography;
+    /** Spacing scale */
+    spacing: Spacing;
+    /** Border radius scale */
+    borderRadius: BorderRadius;
+    /** Responsive breakpoints */
+    breakpoints: Breakpoints;
+    /** Design tokens */
+    tokens?: DesignToken[];
+    /** Customizable theme settings */
+    settings?: FieldDefinition[];
+    /** Current theme settings values */
+    settingsValues?: Settings;
+    /** Custom CSS */
+    customCss?: string;
+    /** Whether this is the active theme */
+    active: boolean;
+    /** Creation timestamp */
+    createdAt: string;
+    /** Last update timestamp */
+    updatedAt: string;
+}
+/**
+ * Theme Preset - Predefined theme configurations
+ */
+interface ThemePreset {
+    /** Preset identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Preview image */
+    preview?: string;
+    /** Theme configuration */
+    config: Omit<ThemeConfig, "id" | "active" | "createdAt" | "updatedAt">;
+    /** Tags for categorization */
+    tags?: string[];
+}
+/**
+ * Theme Export/Import Format
+ */
+interface ThemeExport {
+    /** Export format version */
+    formatVersion: string;
+    /** Exported theme data */
+    theme: ThemeConfig;
+    /** Export timestamp */
+    exportedAt: string;
+    /** Exporter info */
+    exportedBy?: string;
+}
+/**
+ * Theme Manifest - Metadata for third-party theme packages
+ *
+ * @public
+ * This is the primary contract that theme developers must implement.
+ * This interface defines what the platform expects from theme bundles.
+ */
+interface ThemeManifest {
+    /** Unique theme identifier (e.g., "my-awesome-theme") */
+    id: string;
+    /** Human-readable theme name */
+    name: string;
+    /** Semantic version (e.g., "1.0.0") */
+    version: string;
+    /** Theme description */
+    description?: string;
+    /** Theme author information */
+    author: {
+        name: string;
+        email?: string;
+        url?: string;
+    };
+    /** OneX engine version compatibility (e.g., "^1.0.0") */
+    engine: string;
+    /** Required peer dependencies */
+    peerDependencies: {
+        react: string;
+        "react-dom": string;
+        "@onex/core"?: string;
+    };
+    /** Available sections in this theme */
+    sections: string[];
+    /** Theme configuration (colors, typography, etc.) */
+    config: ThemeConfig;
+    /** Entry points for the theme bundle */
+    exports: {
+        /** Main entry point (ESM module) */
+        main: string;
+        /** Type declarations */
+        types?: string;
+    };
+    /** Optional theme preview/screenshot */
+    preview?: {
+        thumbnail?: string;
+        screenshots?: string[];
+    };
+    /** Optional license information */
+    license?: string;
+    /** Optional homepage/repository */
+    repository?: string;
+    /** Optional tags for categorization */
+    tags?: string[];
+}
+/**
+ * Theme Module Interface - What theme ESM bundles export
+ *
+ * @public
+ * Theme bundles must export this structure from their main entry point.
+ */
+interface ThemeModule {
+    /** Theme manifest */
+    manifest: ThemeManifest;
+    /** Section components registry (sectionType -> React component) */
+    sections: Record<string, React.ComponentType<SectionComponentProps>>;
+    /** Theme configuration */
+    config: ThemeConfig;
+    /** Optional theme initialization function */
+    init?: () => void | Promise<void>;
+}
+/**
+ * Validation Result - Result of theme bundle validation
+ *
+ * @public
+ * Returned when validating uploaded theme bundles.
+ */
+interface ThemeValidationResult {
+    /** Whether the theme passed validation */
+    valid: boolean;
+    /** Validation errors (if any) */
+    errors?: ThemeValidationError[];
+    /** Validation warnings (non-blocking) */
+    warnings?: ThemeValidationWarning[];
+}
+/**
+ * Theme Validation Error
+ *
+ * @public
+ */
+interface ThemeValidationError {
+    /** Error code (e.g., "INVALID_MANIFEST", "BUNDLE_TOO_LARGE") */
+    code: string;
+    /** Human-readable error message */
+    message: string;
+    /** Optional path to the problematic field */
+    path?: string;
+}
+/**
+ * Theme Validation Warning
+ *
+ * @public
+ */
+interface ThemeValidationWarning {
+    /** Warning code */
+    code: string;
+    /** Human-readable warning message */
+    message: string;
+    /** Optional path to the problematic field */
+    path?: string;
+}
+/**
+ * Theme Upload Metadata - Information about uploaded theme bundles
+ *
+ * @public
+ * Stored in the database when a theme is uploaded.
+ */
+interface ThemeUpload {
+    /** Unique upload ID */
+    id: string;
+    /** Theme ID from manifest */
+    themeId: string;
+    /** Theme version from manifest */
+    version: string;
+    /** User who uploaded the theme */
+    uploadedBy: string;
+    /** Upload timestamp */
+    uploadedAt: string;
+    /** CDN URL for the theme bundle */
+    bundleUrl: string;
+    /** Bundle size in bytes */
+    bundleSize: number;
+    /** Upload status */
+    status: "pending" | "validated" | "published" | "rejected";
+    /** Validation result (if validated) */
+    validation?: ThemeValidationResult;
+    /** Rejection reason (if rejected) */
+    rejectionReason?: string;
+}
+
+/**
+ * Page Type Definitions
+ * Pages can be either component-based (static TSX) or section-based (composable)
+ */
+
+/**
+ * Page Render Mode
+ * Determines how the page is rendered
+ */
+type PageRenderMode = "component" | "sections";
+/**
+ * Page Type
+ */
+type PageType = "home" | "about" | "contact" | "blog" | "product" | "products" | "cart" | "checkout" | "payment" | "order-success" | "order-failed" | "login" | "register" | "forgot-password" | "verify-code" | "reset-password" | "profile" | "static" | "utility" | "auth" | "custom";
+/**
+ * Schema.org Type for Structured Data
+ */
+type SchemaType = "WebSite" | "Organization" | "Article" | "BlogPosting" | "Product" | "LocalBusiness" | "FAQPage" | "HowTo" | "Person" | "Event";
+/**
+ * Twitter Card Type
+ */
+type TwitterCardType = "summary" | "summary_large_image" | "app" | "player";
+/**
+ * Robots Directive
+ */
+type RobotsDirective = "index" | "noindex" | "follow" | "nofollow" | "noarchive" | "nosnippet" | "noimageindex" | "notranslate";
+/**
+ * Open Graph Metadata
+ */
+interface OpenGraphMeta {
+    /** OG Title (can differ from page title) */
+    title?: string;
+    /** OG Description */
+    description?: string;
+    /** OG Image URL (recommended: 1200x630px) */
+    image?: string;
+    /** OG Image Alt Text */
+    imageAlt?: string;
+    /** OG Type (website, article, product, etc.) */
+    type?: string;
+    /** OG URL (canonical URL for sharing) */
+    url?: string;
+    /** OG Site Name (brand name) */
+    siteName?: string;
+    /** OG Locale (e.g., en_US, vi_VN) */
+    locale?: string;
+    /** Article-specific: author */
+    articleAuthor?: string;
+    /** Article-specific: published time */
+    articlePublishedTime?: string;
+    /** Article-specific: modified time */
+    articleModifiedTime?: string;
+    /** Article-specific: section/category */
+    articleSection?: string;
+    /** Article-specific: tags */
+    articleTags?: string[];
+}
+/**
+ * Twitter Card Metadata
+ */
+interface TwitterCardMeta {
+    /** Card type */
+    card?: TwitterCardType;
+    /** Twitter site account (@username) */
+    site?: string;
+    /** Twitter creator account (@username) */
+    creator?: string;
+    /** Twitter title (can differ from OG title) */
+    title?: string;
+    /** Twitter description */
+    description?: string;
+    /** Twitter image URL */
+    image?: string;
+    /** Twitter image alt text */
+    imageAlt?: string;
+}
+/**
+ * FAQ Schema Item for FAQPage structured data
+ */
+interface FAQSchemaItem {
+    /** Question text */
+    question: string;
+    /** Answer text (supports HTML/markdown) */
+    answer: string;
+    /** Unique identifier */
+    id?: string;
+}
+/**
+ * Structured Data Configuration
+ */
+interface StructuredDataConfig {
+    /** Schema type */
+    type?: SchemaType;
+    /** Schema.org data as JSON-LD object */
+    data?: Record<string, unknown>;
+}
+/**
+ * Page SEO Settings - Comprehensive SEO & AEO Configuration
+ */
+interface PageSEO {
+    /** Page title (50-60 characters recommended) */
+    title?: string;
+    /** Meta description (150-160 characters recommended) */
+    description?: string;
+    /** Meta keywords */
+    keywords?: string[];
+    /** Featured image URL */
+    image?: string;
+    /** Image alt text for accessibility */
+    imageAlt?: string;
+    /** Open Graph metadata */
+    openGraph?: OpenGraphMeta;
+    /** Twitter Card metadata */
+    twitter?: TwitterCardMeta;
+    /** Structured data configuration */
+    structuredData?: StructuredDataConfig;
+    /** FAQ Schema items for FAQPage */
+    faqs?: FAQSchemaItem[];
+    /** Canonical URL */
+    canonical?: string;
+    /** Robots meta directives */
+    robots?: RobotsDirective[] | string;
+    /** Author name */
+    author?: string;
+    /** Published date (ISO 8601) */
+    publishedTime?: string;
+    /** Last modified date (ISO 8601) */
+    modifiedTime?: string;
+    /** Content locale (e.g., en_US, vi_VN) */
+    locale?: string;
+    /** Alternate locales for i18n */
+    alternateLocales?: string[];
+    /** Primary topic/focus keyword */
+    focusKeyword?: string;
+    /** Content type for AI optimization */
+    contentType?: "article" | "guide" | "tutorial" | "product" | "faq" | "comparison";
+    /** Target audience description */
+    targetAudience?: string;
+    /** Enhanced author information (E-E-A-T) */
+    authors?: Array<{
+        name: string;
+        url?: string;
+        image?: string;
+        jobTitle?: string;
+        bio?: string;
+        sameAs?: string[];
+    }>;
+    /** Reviewer information (for review content) */
+    reviewedBy?: {
+        name: string;
+        url?: string;
+        credentials?: string;
+    };
+    /** Content freshness indicators */
+    lastReviewed?: string;
+    contentExpiry?: string;
+    updateFrequency?: "daily" | "weekly" | "monthly" | "yearly" | "as-needed";
+    /** Main entity of the page */
+    mainEntity?: {
+        type: string;
+        name: string;
+        description?: string;
+        sameAs?: string[];
+    };
+    /** Breadcrumb navigation */
+    breadcrumbs?: Array<{
+        name: string;
+        url: string;
+    }>;
+    /** Content classification for AI */
+    contentPurpose?: "inform" | "educate" | "sell" | "entertain" | "compare";
+    audienceExpertiseLevel?: "beginner" | "intermediate" | "expert" | "all";
+    contentDepth?: "overview" | "detailed" | "comprehensive";
+    /** Topic categorization */
+    topics?: string[];
+    /** Citation preferences */
+    citationPreference?: {
+        allowAICitation?: boolean;
+        attributionRequired?: boolean;
+        licensingInfo?: string;
+    };
+    /** AI crawler directives */
+    aiRobots?: {
+        allowGPTBot?: boolean;
+        allowCCBot?: boolean;
+        allowClaudeBot?: boolean;
+        allowBingBot?: boolean;
+    };
+    /** Related content for AI context */
+    relatedPages?: Array<{
+        url: string;
+        title: string;
+        relationship: "prerequisite" | "related" | "next" | "parent";
+    }>;
+    /** Estimated reading/viewing time */
+    estimatedTime?: {
+        value: number;
+        unit: "minutes" | "hours";
+    };
+    /** Additional custom meta tags */
+    meta?: Array<{
+        name?: string;
+        property?: string;
+        content: string;
+    }>;
+}
+/**
+ * Component Page Definition
+ * For registering simple/static pages (pure React components)
+ */
+interface ComponentPageDefinition {
+    /** Unique page identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Page type */
+    type: PageType;
+    /** URL handle/slug */
+    handle: string;
+    /** The React component */
+    component: React$1.ComponentType<Record<string, unknown>>;
+    /** Preview thumbnail */
+    preview?: string;
+    /** Category for organization */
+    category?: "utility" | "auth" | "content" | "custom";
+    /** Tags for searching/filtering */
+    tags?: string[];
+    /** Whether this page can be customized */
+    customizable?: boolean;
+    /** Default SEO settings */
+    defaultSeo?: PageSEO;
+}
+/**
+ * Page Configuration
+ */
+interface PageConfig extends BaseEntity {
+    /** Page title */
+    title: string;
+    /** URL handle/slug (internal identifier) */
+    handle: string;
+    /**
+     * Public URL path
+     * If not specified, defaults to `/${handle}` (except home → "/")
+     * Examples: "/", "/about", "/products/[id]", "/blog/[slug]"
+     */
+    path?: string;
+    /**
+     * Whether this is a dynamic route with parameters
+     * True for paths like "/products/[id]" or "/blog/[slug]"
+     */
+    isDynamic?: boolean;
+    /**
+     * Dynamic route segments (parameter names)
+     * Example: ["id"] for "/products/[id]", ["slug"] for "/blog/[slug]"
+     */
+    dynamicSegments?: string[];
+    /**
+     * Parent page handle (for building breadcrumbs and nested routes)
+     * Example: "products" for a page at "/products/[id]"
+     */
+    parentHandle?: string;
+    /** Page type */
+    type: PageType;
+    /** Render mode: determines how page is rendered */
+    renderMode: PageRenderMode;
+    /** Theme reference */
+    themeId: string;
+    /** For component pages: path to component or component ID */
+    componentPath?: string;
+    /** For section-based pages: sections array */
+    sections?: SectionInstance[];
+    /** Whether the page is editable in visual editor */
+    editable: boolean;
+    /** Page-specific settings */
+    settings?: Settings;
+    /** SEO settings */
+    seo?: PageSEO;
+    /** Whether the page is published */
+    published: boolean;
+    /** Publication date */
+    publishedAt?: string;
+    /** Author/creator */
+    author?: string;
+    /** Template layout (for custom pages) */
+    layout?: string;
+    /** Custom CSS for this page */
+    customCss?: string;
+    /** Custom JavaScript for this page */
+    customJs?: string;
+    /** Version number for change tracking */
+    version?: number;
+}
+/**
+ * Page Template - Predefined page structures
+ */
+interface PageTemplate {
+    /** Unique template identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Preview image */
+    preview?: string;
+    /** Page type this template is for */
+    pageType: PageType;
+    /** Render mode: determines if template is component or section-based */
+    renderMode: PageRenderMode;
+    /** For component-based templates: path to component */
+    componentPath?: string;
+    /** For section-based templates: pre-configured sections */
+    sections?: Omit<SectionInstance, "id" | "createdAt" | "updatedAt">[];
+    /** Default SEO settings */
+    defaultSeo?: PageSEO;
+    /** Tags for categorization */
+    tags?: string[];
+}
+/**
+ * Page List Item - Lightweight representation for page lists
+ */
+interface PageListItem {
+    id: string;
+    title: string;
+    handle: string;
+    type: PageType;
+    published: boolean;
+    updatedAt: string;
+    seo?: {
+        title?: string;
+        description?: string;
+    };
+}
+/**
+ * Page Navigation Item
+ */
+interface PageNavItem {
+    id: string;
+    title: string;
+    handle: string;
+    /** Computed or explicit path for navigation */
+    path?: string;
+    /** Display order in navigation */
+    order: number;
+    /** Nested navigation items */
+    children?: PageNavItem[];
+    /** Whether to show in main navigation */
+    showInNav?: boolean;
+    /** Icon for navigation item */
+    icon?: string;
+}
+/**
+ * Theme Layout Configuration (Legacy)
+ * Defines a theme with header, footer, and global settings
+ * @deprecated Use ThemeConfig from './theme' for new implementations
+ */
+interface ThemeLayoutConfig {
+    /** Unique theme identifier */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Theme version */
+    version: string;
+    /** Header sections to prepend to all pages */
+    headerSections?: SectionInstance[];
+    /** Footer sections to append to all pages */
+    footerSections?: SectionInstance[];
+    /** Global design settings/tokens */
+    globalSettings?: {
+        /** Primary brand color */
+        primaryColor?: string;
+        /** Secondary color */
+        secondaryColor?: string;
+        /** Font family */
+        fontFamily?: string;
+        /** Spacing scale */
+        spacing?: string;
+        /** Additional custom settings */
+        [key: string]: unknown;
+    };
+    /** Creation timestamp */
+    createdAt?: string;
+    /** Last update timestamp */
+    updatedAt?: string;
+}
+
+/**
+ * JSON-serializable value type
+ */
+type JSONValue = string | number | boolean | null | JSONObject | JSONArray;
+interface JSONObject {
+    [key: string]: JSONValue;
+}
+type JSONArray = JSONValue[];
+/**
+ * Element Type Enumeration
+ * Visual DOM element types that can be edited inline
+ * (Different from FieldType which defines settings panel inputs)
+ */
+type ElementType = "text" | "button" | "image" | "link" | "video" | "icon" | "form" | "richtext" | "chart" | "map" | "countdown";
+/**
+ * Element Metadata
+ * Information about a selected editable element
+ */
+interface ElementMetadata {
+    /** Component instance ID (if element is a component instance) */
+    componentId?: string;
+    /** Field ID from section/component schema */
+    fieldId: string;
+    /** Human-readable field label */
+    fieldLabel: string;
+    /** Type of visual element */
+    elementType: ElementType;
+    /** Parent section ID */
+    sectionId: string;
+    /** Parent block ID (if element is inside a block) */
+    blockId?: string;
+    /** Whether to show inline popover editor */
+    isInline: boolean;
+    /** Element's bounding rectangle */
+    bounds: DOMRect;
+    /** Current field value */
+    currentValue: SettingValue;
+}
+/**
+ * Detection Priority
+ * Defines the order in which elements are detected
+ */
+type DetectionPriority = "component" | "block" | "section";
+/**
+ * Detection Strategy
+ * Controls how the inspector overlay detects selectable items
+ */
+interface DetectionStrategy {
+    /** Priority order for detection (element → component → block → section) */
+    priority: DetectionPriority[];
+    /** Whether to stop at first match or continue traversing */
+    stopAtFirstMatch: boolean;
+    /** Maximum depth to traverse up the DOM tree */
+    maxDepth?: number;
+}
+/**
+ * Detection Result
+ * Result of DOM traversal detection
+ */
+type DetectionResult = {
+    type: "component";
+    sectionId: string;
+    componentId: string;
+    componentType: string;
+    element: HTMLElement;
+} | {
+    type: "block";
+    sectionId: string;
+    blockId: string;
+    element: HTMLElement;
+} | {
+    type: "section";
+    sectionId: string;
+    element: HTMLElement;
+} | {
+    type: "none";
+};
+/**
+ * Inline Editor State
+ */
+interface InlineEditorState {
+    /** Whether inline editor is visible */
+    visible: boolean;
+    /** Position for popover */
+    position: {
+        top: number;
+        left: number;
+    };
+    /** Type of element being edited */
+    elementType: ElementType;
+    /** Current value */
+    currentValue: SettingValue;
+    /** Field definition from schema */
+    fieldDefinition?: FieldDefinition;
+}
+/**
+ * Props for inline editor components
+ */
+interface InlineEditorProps {
+    /** Selected element info */
+    selectedElement: SelectedElement;
+    /** Current field value */
+    currentValue: SettingValue;
+    /** Field definition from schema */
+    fieldDefinition: FieldDefinition;
+    /** Update callback */
+    onUpdate: (value: SettingValue) => void;
+    /** Close callback */
+    onClose: () => void;
+    /** Popover position */
+    position?: {
+        top: number;
+        left: number;
+    };
+}
+/**
+ * Inspector Configuration
+ */
+interface InspectorConfig {
+    /** Detection strategy (element-first by default) */
+    strategy: DetectionStrategy;
+    /** Whether to show element outlines on hover */
+    showElementOutlines: boolean;
+    /** Whether to show element tooltips */
+    showTooltips: boolean;
+    /** Outline color for different types */
+    outlineColors: {
+        component: string;
+        block: string;
+        section: string;
+    };
+}
+/**
+ * Default Inspector Configuration
+ * Detection priority: component → block → section
+ */
+declare const DEFAULT_INSPECTOR_CONFIG: InspectorConfig;
+/**
+ * Editor Mode
+ */
+type EditorMode = "view" | "edit" | "preview";
+/**
+ * Icon Sidebar View
+ * Determines which panel is shown in the left sidebar
+ */
+type IconSidebarView = "sections" | "page-seo" | "theme-settings";
+/**
+ * Selected Element Type
+ */
+type SelectedElementType = "section" | "block" | "component" | "none";
+/**
+ * Selected Element Info
+ */
+interface SelectedElement {
+    /** Type of selected element */
+    type: SelectedElementType;
+    /** Element ID */
+    id: string;
+    /** Section ID (for section, component, block, and element selections) */
+    sectionId: string;
+    /** Component ID (only for component selections) */
+    componentId?: string;
+    /** Component type (only for component selections) */
+    componentType?: string;
+    /** Block ID (only for block selections) */
+    blockId?: string;
+    /** Block type (only for block selections) */
+    blockType?: string;
+    /** DOM element reference */
+    element?: HTMLElement;
+    /** Bounding rect for overlay positioning */
+    rect?: DOMRect;
+}
+/**
+ * Editor State
+ */
+interface EditorState {
+    /** Current editor mode */
+    mode: EditorMode;
+    /** Currently selected element */
+    selected: SelectedElement | null;
+    /** Whether the settings panel is open */
+    settingsPanelOpen: boolean;
+    /** Whether the sections panel is open */
+    sectionsPanelOpen: boolean;
+    /** Current page being edited */
+    pageId: string | null;
+    /** Whether there are unsaved changes */
+    hasUnsavedChanges: boolean;
+    /** Undo/redo stack depth */
+    historyIndex: number;
+    /** Total history entries */
+    historyLength: number;
+    /** Current icon sidebar view (sections or theme settings) */
+    iconSidebarView: IconSidebarView;
+    /** Current theme configuration */
+    themeConfig: ThemeLayoutConfig | null;
+    /** Left panel width (for persistence) */
+    leftPanelWidth: number;
+    /** Current company ID */
+    companyId: string;
+    /** Current theme ID */
+    themeId: string;
+    /** Available section schemas for the current theme */
+    themeSchemas: SectionSchema[];
+    /** Page SEO configuration */
+    pageSeo: PageSEO | null;
+}
+/**
+ * Editor Actions
+ */
+interface EditorActions {
+    /** Set editor mode */
+    setMode: (mode: EditorMode) => void;
+    /** Select an element */
+    selectElement: (element: SelectedElement | null) => void;
+    /** Toggle settings panel */
+    toggleSettingsPanel: (open?: boolean) => void;
+    /** Toggle sections panel */
+    toggleSectionsPanel: (open?: boolean) => void;
+    /** Update section settings */
+    updateSectionSettings: (sectionId: string, settings: Settings) => void;
+    /** Update component settings */
+    updateComponentSettings: (sectionId: string, componentId: string, updates: Partial<{
+        content: Settings;
+        style: Settings;
+    }>) => void;
+    /** Update block settings */
+    updateBlockSettings: (sectionId: string, blockId: string, settings: Settings) => void;
+    /** Add section to page */
+    addSection: (sectionType: string, templateId: string, order?: number) => void;
+    /** Remove section from page */
+    removeSection: (sectionId: string) => void;
+    /** Reorder sections */
+    reorderSections: (sectionIds: string[]) => void;
+    /** Add component to section */
+    addComponent: (sectionId: string, componentType: string) => void;
+    /** Remove component from section */
+    removeComponent: (sectionId: string, componentId: string) => void;
+    /** Reorder components in section */
+    reorderComponents: (sectionId: string, componentIds: string[]) => void;
+    /** Add block to section */
+    addBlock: (sectionId: string, blockType: string) => void;
+    /** Remove block from section */
+    removeBlock: (sectionId: string, blockId: string) => void;
+    /** Reorder blocks in section */
+    reorderBlocks: (sectionId: string, blockIds: string[]) => void;
+    /** Duplicate section */
+    duplicateSection: (sectionId: string) => void;
+    /** Toggle section visibility */
+    toggleSectionVisibility: (sectionId: string) => void;
+    /** Change section template */
+    changeSectionTemplate: (sectionId: string, templateId: string) => void;
+    /** Replace all sections (used when switching page templates) */
+    replaceAllSections: (newSections: SectionInstance[]) => void;
+    /** Save changes */
+    save: () => Promise<void>;
+    /** Discard changes */
+    discard: () => void;
+    /** Undo last action */
+    undo: () => void;
+    /** Redo last undone action */
+    redo: () => void;
+    /** Check if can undo */
+    canUndo: () => boolean;
+    /** Check if can redo */
+    canRedo: () => boolean;
+    /** Set icon sidebar view */
+    setIconSidebarView: (view: IconSidebarView) => void;
+    /** Load theme configuration */
+    loadThemeConfig: (themeId: string) => Promise<void>;
+    /** Update theme global settings */
+    updateThemeGlobalSettings: (settings: Record<string, unknown>) => void;
+    /** Update theme metadata */
+    updateThemeMetadata: (metadata: Partial<ThemeLayoutConfig>) => void;
+    /** Save theme configuration */
+    saveThemeConfig: () => Promise<void>;
+    /** Add header section to theme */
+    addHeaderSection: (sectionType: string, templateId: string) => void;
+    /** Remove header section from theme */
+    removeHeaderSection: (index: number) => void;
+    /** Update header section in theme */
+    updateHeaderSection: (index: number, updates: Record<string, unknown>) => void;
+    /** Add footer section to theme */
+    addFooterSection: (sectionType: string, templateId: string) => void;
+    /** Remove footer section from theme */
+    removeFooterSection: (index: number) => void;
+    /** Update footer section in theme */
+    updateFooterSection: (index: number, updates: Record<string, unknown>) => void;
+    /** Set left panel width */
+    setLeftPanelWidth: (width: number) => void;
+    /** Update page SEO */
+    updatePageSeo: (seo: Partial<PageSEO>) => void;
+}
+/**
+ * Editor Context Value
+ */
+interface EditorContextValue {
+    /** Current state */
+    state: EditorState;
+    /** Available actions */
+    actions: EditorActions;
+    /** Current page sections */
+    sections: SectionInstance[];
+}
+/**
+ * Inspector Overlay State
+ */
+interface InspectorOverlayState {
+    /** Hovered element info */
+    hovered: SelectedElement | null;
+    /** Whether to show overlay */
+    visible: boolean;
+}
+/**
+ * Change History Entry
+ */
+interface HistoryEntry {
+    /** Unique entry ID */
+    id: string;
+    /** Action type */
+    action: string;
+    /** Previous state snapshot */
+    before: JSONValue;
+    /** New state snapshot */
+    after: JSONValue;
+    /** Timestamp */
+    timestamp: Date;
+    /** User-friendly description */
+    description: string;
+}
+/**
+ * Drag and Drop Context
+ */
+interface DragDropContext {
+    /** Item being dragged */
+    draggedItem: {
+        type: "section" | "component" | "block";
+        id: string;
+        data: SectionInstance | SectionComponentInstance | BlockInstance;
+    } | null;
+    /** Drop target info */
+    dropTarget: {
+        type: "section" | "component" | "block";
+        id: string;
+        position: "before" | "after" | "inside";
+    } | null;
+    /** Start dragging */
+    startDrag: (item: DragDropContext["draggedItem"]) => void;
+    /** Update drop target */
+    updateDropTarget: (target: DragDropContext["dropTarget"]) => void;
+    /** End dragging */
+    endDrag: () => void;
+}
+/**
+ * Keyboard Shortcuts
+ */
+interface KeyboardShortcut {
+    /** Shortcut key combination */
+    keys: string[];
+    /** Action to perform */
+    action: () => void;
+    /** Description */
+    description: string;
+    /** Whether enabled */
+    enabled?: boolean;
+}
+
+/**
+ * Registry Type Definitions
+ * Types for the section, block, and page registry system
+ */
+
+/**
+ * Registry Configuration
+ */
+interface RegistryConfig {
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Allow overriding existing registrations */
+    allowOverride?: boolean;
+    /** Maximum number of sections that can be registered */
+    maxSections?: number;
+    /** Maximum number of blocks that can be registered */
+    maxBlocks?: number;
+}
+/**
+ * Registry Event Types
+ */
+type RegistryEventType = "section:registered" | "section:unregistered" | "block:registered" | "block:unregistered" | "template:registered" | "page:registered" | "page:unregistered" | "page-template:registered";
+/**
+ * Registry Event Payload Union
+ */
+type RegistryEventPayload = SectionRegisteredPayload | SectionUnregisteredPayload | TemplateRegisteredPayload | BlockRegisteredPayload | BlockUnregisteredPayload;
+/**
+ * Registry Event
+ */
+interface RegistryEvent<TPayload = RegistryEventPayload> {
+    /** Event type */
+    type: RegistryEventType;
+    /** Event payload */
+    payload: TPayload;
+    /** Event timestamp */
+    timestamp: Date;
+}
+/**
+ * Section Registry Event Payloads
+ */
+interface SectionRegisteredPayload {
+    type: string;
+    schema: SectionSchema;
+    templates: TemplateDefinition[];
+}
+interface SectionUnregisteredPayload {
+    type: string;
+}
+interface TemplateRegisteredPayload {
+    sectionType: string;
+    templateId: string;
+    template: TemplateDefinition;
+}
+/**
+ * Block Registry Event Payloads
+ */
+interface BlockRegisteredPayload {
+    type: string;
+    definition: BlockDefinition;
+}
+interface BlockUnregisteredPayload {
+    type: string;
+}
+/**
+ * Registry Event Handler
+ */
+type RegistryEventHandler<TPayload = RegistryEventPayload> = (event: RegistryEvent<TPayload>) => void;
+/**
+ * Section Registry Interface
+ */
+interface SectionRegistry {
+    /**
+     * Register a section type with its templates
+     */
+    register<T>(sectionType: string, schema: SectionSchema, component: React.ComponentType<T> | (() => Promise<React.ComponentType<T>>), options?: {
+        templates?: Array<{
+            definition: TemplateDefinition;
+            component: React.ComponentType<SectionComponentProps>;
+        }>;
+        category?: string;
+        tags?: string[];
+    }): void;
+    /**
+     * Get a section registration
+     */
+    get<T>(sectionType: string): Promise<SectionRegistration<T> | undefined>;
+    /**
+     * Get just the schema without loading the component (server-safe)
+     */
+    getSchema(sectionType: string): SectionSchema | undefined;
+    /**
+     * Get a specific template for a section
+     */
+    getTemplate(sectionType: string, templateId: string): TemplateDefinition | undefined;
+    /**
+     * Get template component
+     */
+    getTemplateComponent(sectionType: string, templateId: string): React.ComponentType<SectionComponentProps> | undefined;
+    /**
+     * Check if a section is registered
+     */
+    has(sectionType: string): boolean;
+    /**
+     * Unregister a section
+     */
+    unregister(sectionType: string): boolean;
+    /**
+     * Get all registered sections
+     */
+    getAll(): Map<string, SectionRegistration>;
+    /**
+     * Search sections by category
+     */
+    getByCategory(category: string): SectionRegistration[];
+    /**
+     * Search sections by tags
+     */
+    getByTags(tags: string[]): SectionRegistration[];
+    /**
+     * Add event listener
+     */
+    on<TPayload = RegistryEventPayload>(eventType: RegistryEventType, handler: RegistryEventHandler<TPayload>): void;
+    /**
+     * Remove event listener
+     */
+    off<TPayload = RegistryEventPayload>(eventType: RegistryEventType, handler: RegistryEventHandler<TPayload>): void;
+    /**
+     * Clear all registrations
+     */
+    clear(): void;
+}
+/**
+ * Block Registry Interface
+ */
+interface BlockRegistry {
+    /**
+     * Register a block type
+     */
+    register<T>(blockType: string, definition: BlockDefinition, component: React.ComponentType<T>, options?: {
+        category?: string;
+        tags?: string[];
+    }): void;
+    /**
+     * Get a block registration
+     */
+    get(blockType: string): BlockRegistration | undefined;
+    /**
+     * Check if a block is registered
+     */
+    has(blockType: string): boolean;
+    /**
+     * Unregister a block
+     */
+    unregister(blockType: string): boolean;
+    /**
+     * Get all registered blocks
+     */
+    getAll(): Map<string, BlockRegistration>;
+    /**
+     * Add event listener
+     */
+    on<TPayload = RegistryEventPayload>(eventType: RegistryEventType, handler: RegistryEventHandler<TPayload>): void;
+    /**
+     * Remove event listener
+     */
+    off<TPayload = RegistryEventPayload>(eventType: RegistryEventType, handler: RegistryEventHandler<TPayload>): void;
+    /**
+     * Clear all registrations
+     */
+    clear(): void;
+}
+/**
+ * Detected Section Element Info
+ */
+interface DetectedSection {
+    /** Element ID from data-section-id */
+    id: string;
+    /** DOM element reference */
+    element: HTMLElement;
+    /** Section type from data-section */
+    type: string;
+    /** Template ID from data-section-template */
+    template: string;
+    /** Section name from data-section-name */
+    name: string;
+    /** Section category */
+    category: string;
+    /** Available settings for this section/template */
+    settings: FieldDefinition[];
+}
+/**
+ * Element Registry Interface (for DOM element tracking)
+ */
+interface ElementRegistry {
+    /**
+     * Register a detected section element
+     */
+    register(info: DetectedSection): void;
+    /**
+     * Get section info by ID
+     */
+    get(id: string): DetectedSection | undefined;
+    /**
+     * Get section info by DOM element
+     */
+    getByElement(element: HTMLElement): DetectedSection | undefined;
+    /**
+     * Check if element is registered
+     */
+    has(element: HTMLElement): boolean;
+    /**
+     * Unregister by ID
+     */
+    unregister(id: string): void;
+    /**
+     * Get all detected sections
+     */
+    getAll(): DetectedSection[];
+    /**
+     * Clear all registrations
+     */
+    clear(): void;
+}
+/**
+ * Page Registration (Component Pages)
+ */
+interface PageRegistration {
+    /** Page definition */
+    definition: ComponentPageDefinition;
+    /** React component */
+    component: React.ComponentType<Record<string, unknown>>;
+    /** Registration timestamp */
+    registeredAt: Date;
+    /** Category for organization */
+    category: string;
+    /** Tags for searching */
+    tags: string[];
+}
+/**
+ * Page Template Registration
+ */
+interface PageTemplateRegistration {
+    /** Template definition */
+    template: PageTemplate;
+    /** Registration timestamp */
+    registeredAt: Date;
+    /** Page type category */
+    category: string;
+    /** Tags for searching */
+    tags: string[];
+}
+/**
+ * Detected Editable Element Info
+ * Tracks editable elements in the DOM
+ */
+interface DetectedElement {
+    /** Field ID from data-field-id attribute */
+    fieldId: string;
+    /** Element type from data-element-type attribute */
+    elementType: ElementType;
+    /** DOM element reference */
+    element: HTMLElement;
+    /** Parent section ID */
+    sectionId: string;
+    /** Parent block ID (if element is inside a block) */
+    blockId?: string;
+    /** Field label for display */
+    fieldLabel: string;
+    /** Whether inline editing is enabled for this element */
+    isInline: boolean;
+    /** Current value */
+    currentValue: SettingValue;
+    /** Field definition from schema */
+    fieldDefinition: FieldDefinition;
+    /** Last updated timestamp */
+    lastUpdated?: Date;
+}
+/**
+ * Editable Element Registry Interface
+ * Runtime registry for tracking editable elements in the DOM
+ */
+interface EditableElementRegistry {
+    /**
+     * Register an editable element
+     */
+    register(info: DetectedElement): void;
+    /**
+     * Get element info by field ID
+     */
+    get(sectionId: string, fieldId: string): DetectedElement | undefined;
+    /**
+     * Get element info by DOM element
+     */
+    getByElement(element: HTMLElement): DetectedElement | undefined;
+    /**
+     * Check if element is registered
+     */
+    has(element: HTMLElement): boolean;
+    /**
+     * Unregister by field ID
+     */
+    unregister(sectionId: string, fieldId: string): void;
+    /**
+     * Get all elements in a section
+     */
+    getBySectionId(sectionId: string): DetectedElement[];
+    /**
+     * Get all elements in a block
+     */
+    getByBlockId(sectionId: string, blockId: string): DetectedElement[];
+    /**
+     * Clear all registrations
+     */
+    clear(): void;
+    /**
+     * Get all registered elements
+     */
+    getAll(): DetectedElement[];
+}
+
+/**
+ * Product Type Definitions
+ * Framework-agnostic product types for e-commerce themes
+ */
+/**
+ * Product Category Type
+ * Can be extended with custom categories
+ */
+type ProductCategory = string;
+/**
+ * Product Tag - supports dynamic tags
+ */
+type ProductTag = string;
+/**
+ * Price Range for filtering
+ */
+type PriceRange = "all" | "0-199k" | "200k-499k" | "500k-1m" | string;
+/**
+ * Sort Options
+ */
+type SortOption = "bestDeals" | "priceLowToHigh" | "priceHighToLow" | "newest" | "bestSelling";
+/**
+ * Product Size
+ */
+interface ProductSize {
+    size: string;
+    inStock: boolean;
+}
+/**
+ * Product Price Group
+ */
+interface ProductPriceGroup {
+    id: string;
+    name: string;
+}
+/**
+ * Product Price
+ */
+interface ProductPrice {
+    price: number;
+    price_group: ProductPriceGroup;
+}
+/**
+ * Product Measurements
+ */
+interface ProductMeasurements {
+    weight_unit?: string;
+    weight_value?: string;
+    width_unit?: string;
+    width_value?: string;
+    length_unit?: string;
+    length_value?: string;
+    height_unit?: string;
+    height_value?: string;
+}
+/**
+ * Product Specifications
+ */
+interface ProductSpecs {
+    thickness?: string;
+    lightTransmission?: string;
+    reflection?: string;
+    uvProtection?: string;
+    irRejection?: string;
+    warranty?: string;
+    [key: string]: string | undefined;
+}
+/**
+ * Product Option (e.g., Size, Color)
+ */
+interface ProductOption {
+    name: string;
+    values: string[];
+}
+/**
+ * Product Variant - Full variant with all options
+ */
+interface ProductVariant {
+    /** Variant ID */
+    id: string;
+    /** Variant name */
+    name: string;
+    /** Variant SKU */
+    sku: string;
+    /** Option 1 value (e.g., "0.5m×0.5m") */
+    option1: string;
+    /** Option 1 title (e.g., "Kích thước") */
+    optionTitle1: string | null;
+    /** Option 2 value (e.g., "Black") */
+    option2: string;
+    /** Option 2 title (e.g., "Màu sắc") */
+    optionTitle2: string | null;
+    /** Option 3 value */
+    option3: string;
+    /** Option 3 title */
+    optionTitle3: string | null;
+    /** Variant images */
+    images: string[];
+    /** Variant prices */
+    prices: ProductPrice[];
+    /** Variant inventories */
+    inventories: unknown;
+    /** Variant slug */
+    slug: string;
+    /** Variant measurements */
+    measurements?: ProductMeasurements;
+    /** Variant availability */
+    inStock?: boolean;
+    /** Variant price (simplified) */
+    price?: number;
+    /** Variant image (simplified) */
+    image?: string;
+}
+/**
+ * Product - Domain model for products
+ * This is the transformed product data used throughout the application
+ */
+interface Product {
+    /** Product unique identifier */
+    id: string;
+    /** Product title/name */
+    title: string;
+    /** URL-friendly slug */
+    slug?: string;
+    /** Product category slug */
+    category: string;
+    /** Product category display name */
+    categoryLabel: string;
+    /** Primary product image URL */
+    image: string;
+    /** Additional product images */
+    images?: string[];
+    /** Selling price (RETAILS price group) */
+    salePrice: number;
+    /** Original/wholesale price (for discount calculation) */
+    originalPrice: number;
+    /** Discount percentage or string (calculated) */
+    discount?: string | number;
+    /** Product description */
+    description?: string;
+    /** Product tags */
+    tags?: string[];
+    /** Product sizes */
+    sizes?: ProductSize[];
+    /** Product badge */
+    badge?: "hot" | "new" | "sale";
+    /** Is best deal */
+    isBestDeal?: boolean;
+    /** Is new product */
+    isNew?: boolean;
+    /** Product availability */
+    inStock?: boolean;
+    /** Product rating (0-5) */
+    rating?: number;
+    /** Number of reviews */
+    reviewCount?: number;
+    /** Product variants (sizes, colors, etc.) */
+    variants?: ProductVariant[];
+    /** Product options */
+    options?: ProductOption[];
+    /** Product specifications */
+    specs?: ProductSpecs;
+    /** Product dimensions */
+    dimensions?: string;
+    /** Product measurements */
+    measurements?: ProductMeasurements;
+    /** Product metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Product Filters
+ */
+interface ProductFilters {
+    category: ProductCategory;
+    priceRange: PriceRange;
+    tags: ProductTag[];
+    sortBy: SortOption;
+}
+/**
+ * Product List Item (lightweight for lists)
+ */
+interface ProductListItem {
+    id: string;
+    title: string;
+    slug: string;
+    image: string;
+    salePrice: number;
+    originalPrice: number;
+    discount?: number;
+    category: string;
+}
+/**
+ * Product Card Props
+ */
+interface ProductCardProps extends Product {
+    /** Click handler */
+    onClick?: () => void;
+    /** Show quick add button */
+    showQuickAdd?: boolean;
+    /** Custom class name */
+    className?: string;
+}
+
+/**
+ * Blog Type Definitions
+ * Framework-agnostic blog types for content themes
+ */
+/**
+ * Blog category type
+ */
+type BlogCategory = string;
+/**
+ * Blog image object from API
+ */
+interface BlogImage {
+    id: string;
+    url: string;
+    name: string;
+}
+/**
+ * Blog author/user object from API
+ */
+interface BlogUser {
+    id: string;
+    name_staff: string;
+    name: string | null;
+    picture: string;
+}
+/**
+ * Blog category object from API
+ */
+interface BlogCategoryData {
+    id: string;
+    name: string;
+    slug: string;
+    image: BlogImage | null;
+    blog_total?: number;
+    has_children?: boolean;
+    locale?: string;
+    description?: string | null;
+}
+/**
+ * Blog SEO metadata
+ */
+interface BlogMetaData {
+    title?: string;
+    description?: string;
+    keywords?: string;
+    author?: string | null;
+    image?: string | null;
+    url?: string | null;
+}
+/**
+ * Response metadata for SEO
+ */
+interface ResponseMetaData {
+    title?: string;
+    description?: string;
+    keywords?: string[];
+    author?: string;
+    image?: string;
+}
+/**
+ * Main Blog interface
+ */
+interface Blog {
+    /** Blog unique identifier */
+    id: string;
+    /** Blog title */
+    title: string;
+    /** URL-friendly slug */
+    slug: string;
+    /** Short description/summary */
+    description: string;
+    /** Short excerpt (alias for description, for backwards compatibility) */
+    excerpt?: string;
+    /** HTML content (only in detail view) */
+    content?: string;
+    /** Primary blog image */
+    image: string;
+    /** Cover image URL (only in detail view) */
+    coverImage?: string;
+    /** Category slug */
+    category: string;
+    /** Category display name */
+    categoryLabel: string;
+    /** Full category object */
+    categoryData?: BlogCategoryData;
+    /** Blog author */
+    author?: BlogUser;
+    /** Blog tags */
+    tags?: string[];
+    /** Whether published */
+    publish?: boolean;
+    /** Blog status */
+    status?: "DRAFT" | "PUBLISHED" | "ARCHIVED";
+    /** ISO date string when created */
+    createdAt?: string;
+    /** ISO date string when last updated */
+    updatedAt?: string;
+    /** ISO date string when published (alias for backwards compatibility) */
+    publishedAt?: string;
+    /** Locale */
+    locale?: string;
+    /** SEO metadata (only in detail view) */
+    metaData?: BlogMetaData;
+    /** Related blog IDs */
+    relatedBlogIds?: string[];
+    /** Total number of comments */
+    totalComments?: number;
+    /** Search relevance score */
+    score?: number;
+    /** Blog type */
+    blogType?: string;
+}
+/**
+ * Blog filters for client-side filtering
+ */
+interface BlogFilters {
+    category: BlogCategory;
+    search?: string;
+}
+/**
+ * Blog detail data from API
+ */
+interface BlogDetailData {
+    id: string;
+    title: string;
+    content: string;
+    updated_at: string;
+    locale: string;
+    created_at: string;
+    category: BlogCategoryData;
+    meta_data?: ResponseMetaData;
+    slug: string;
+    image?: {
+        url: string;
+    };
+    description?: string;
+}
+/**
+ * Blog list data from API
+ */
+interface BlogListData {
+    items: BlogDetailData[];
+    total: number;
+    page: number;
+    limit: number;
+}
+/**
+ * Blog list item (lightweight for lists)
+ */
+interface BlogListItem {
+    id: string;
+    title: string;
+    slug: string;
+    description: string;
+    image: string;
+    category: string;
+    categoryLabel: string;
+    createdAt: string;
+}
+
+/**
+ * Cart Type Definitions
+ * Types for shopping cart functionality
+ */
+interface CartItem {
+    /** Unique cart item ID */
+    id: string;
+    /** Product ID */
+    productId: string;
+    /** Product slug for navigation */
+    slug?: string;
+    /** Product name */
+    name: string;
+    /** Product image URL */
+    image: string;
+    /** Selected size (optional - only if product has size option) */
+    size?: string;
+    /** Selected color (optional - only if product has color option) */
+    color?: string;
+    /** Label for size option (e.g., "Kích thước") */
+    sizeLabel?: string;
+    /** Label for color option (e.g., "Màu sắc") */
+    colorLabel?: string;
+    /** Unit price */
+    price: number;
+    /** Quantity */
+    quantity: number;
+    /** Variant ID (for products with variants) */
+    variantId?: string;
+    /** SKU */
+    sku?: string;
+    /** Location ID selected when adding to cart */
+    locationId?: string | null;
+}
+interface CartSummary {
+    /** Subtotal (sum of item prices) */
+    subtotal: number;
+    /** Shipping cost */
+    shipping: number;
+    /** Total amount */
+    total: number;
+}
+interface CartContextType {
+    /** Cart items */
+    items: CartItem[];
+    /** Add item to cart */
+    addItem: (item: Omit<CartItem, "id" | "quantity">) => void;
+    /** Remove item from cart */
+    removeItem: (id: string) => void;
+    /** Update item quantity */
+    updateQuantity: (id: string, quantity: number) => void;
+    /** Clear all items from cart */
+    clearCart: () => void;
+    /** Total number of items in cart */
+    itemCount: number;
+    /** Subtotal price */
+    subtotal: number;
+}
+
+/**
+ * API Response Types
+ * Generic types for API responses
+ */
+/**
+ * Generic API response wrapper
+ */
+interface ApiResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    message?: string;
+    error?: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+    meta?: Record<string, unknown>;
+}
+/**
+ * Paginated API response
+ */
+interface PaginatedResponse<T = unknown> {
+    items: T[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+        hasNext: boolean;
+        hasPrev: boolean;
+    };
+}
+/**
+ * Server fetcher response (used by server-side data fetchers)
+ * Wraps data with success/error state and pagination
+ */
+interface ServerFetcherResponse<T = unknown> {
+    success: boolean;
+    data: T[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+        hasNext: boolean;
+        hasPrev: boolean;
+    };
+    message?: string;
+}
+/**
+ * API list response (with pagination)
+ * Flat structure returned directly from the API
+ */
+interface ApiListResponse<T = unknown> {
+    items: T[];
+    total: number;
+    page: number;
+    limit: number;
+}
+/**
+ * Generic list query parameters
+ */
+interface ListQueryParams {
+    page?: number;
+    limit?: number;
+    sort?: string;
+    order?: "asc" | "desc";
+    search?: string;
+    [key: string]: unknown;
+}
+/**
+ * Location data structure
+ */
+interface Location {
+    id: string;
+    name: string;
+    address?: string;
+    city?: string;
+    state?: string;
+    country?: string;
+    zipCode?: string;
+    phone?: string;
+    email?: string;
+    coordinates?: {
+        lat: number;
+        lng: number;
+    };
+    [key: string]: unknown;
+}
+/**
+ * Location list response
+ */
+type LocationListResponse = ApiResponse<Location[]>;
+/**
+ * Price group data structure
+ */
+interface ApiPriceGroup {
+    price: number;
+    price_group: {
+        id: string;
+        name: string;
+    };
+}
+/**
+ * Raw product data from API
+ */
+interface ApiProductRaw {
+    id: string;
+    name: string;
+    slug: string;
+    price: number;
+    description?: string;
+    images?: Array<{
+        url: string;
+        alt?: string;
+    }>;
+    category?: {
+        id: string;
+        slug: string;
+        name: string;
+    };
+    tags?: string;
+    stock?: number;
+    sku?: string;
+    publish?: boolean;
+    prices?: ApiPriceGroup[];
+    variants?: Array<{
+        prices?: ApiPriceGroup[];
+        [key: string]: unknown;
+    }>;
+    [key: string]: unknown;
+}
+/**
+ * Product filters query parameters
+ */
+interface ProductFiltersParams extends ListQueryParams {
+    category?: string;
+    tags?: string[];
+    minPrice?: number;
+    maxPrice?: number;
+    inStock?: boolean;
+}
+/**
+ * Blog filters query parameters
+ */
+interface BlogFiltersParams extends ListQueryParams {
+    category?: string;
+    tags?: string[];
+    author?: string;
+    dateFrom?: string;
+    dateTo?: string;
+}
+
+export { type ApplyScope as $, type AnimationType as A, type BaseEntity as B, type ColorFieldDefinition as C, type SectionInstance as D, type SectionComponentInstance as E, type FieldType as F, type SectionRegistration as G, type SectionComponentProps as H, type ImageFieldDefinition as I, type SectionCategory as J, SECTION_CATEGORIES as K, type ComponentType as L, type ComponentCategory as M, type NumberFieldDefinition as N, type ComponentDefinition as O, type ProductFieldDefinition as P, type ComponentInstance as Q, type RangeFieldDefinition as R, type SelectFieldDefinition as S, type TextFieldDefinition as T, type UrlFieldDefinition as U, type VideoFieldDefinition as V, type ComponentRegistration as W, type ComponentProps as X, type StyleSettings as Y, type Breakpoint as Z, type ResponsiveStyles as _, type AnimationEasing as a, type SettingsIcon as a$, type ApplyScopeResult as a0, COMPONENT_CATEGORIES as a1, COMPONENT_TYPES as a2, type PageType as a3, type PageSEO as a4, type PageConfig as a5, type PageTemplate as a6, type PageListItem as a7, type PageNavItem as a8, type PageRenderMode as a9, type SectionRegistry as aA, type BlockRegistry as aB, type DetectedSection as aC, type ElementRegistry as aD, type DetectedElement as aE, type EditableElementRegistry as aF, type PageRegistration as aG, type PageTemplateRegistration as aH, type EditorMode as aI, type SelectedElementType as aJ, type SelectedElement as aK, type EditorState as aL, type EditorActions as aM, type EditorContextValue as aN, type InspectorOverlayState as aO, type HistoryEntry as aP, type DragDropContext as aQ, type KeyboardShortcut as aR, type ElementType as aS, type ElementMetadata as aT, type DetectionPriority as aU, type DetectionStrategy as aV, type DetectionResult as aW, type InlineEditorState as aX, type InlineEditorProps as aY, type InspectorConfig as aZ, DEFAULT_INSPECTOR_CONFIG as a_, type ThemeLayoutConfig as aa, type ComponentPageDefinition as ab, type DesignToken as ac, type ColorPalette as ad, type Typography as ae, type Spacing as af, type BorderRadius as ag, type Breakpoints as ah, type ThemeConfig as ai, type ThemePreset as aj, type ThemeExport as ak, type ThemeManifest as al, type ThemeModule as am, type ThemeUpload as an, type ThemeValidationResult as ao, type ThemeValidationError as ap, type ThemeValidationWarning as aq, type RegistryConfig as ar, type RegistryEventType as as, type RegistryEvent as at, type SectionRegisteredPayload as au, type SectionUnregisteredPayload as av, type TemplateRegisteredPayload as aw, type BlockRegisteredPayload as ax, type BlockUnregisteredPayload as ay, type RegistryEventHandler as az, type AnimationTrigger as b, type SocialPlatform as b0, type SocialConnection as b1, type HotlineType as b2, type HotlineConnection as b3, type TrackingPlatform as b4, type TrackingAnalytics as b5, type ContactEmail as b6, type CompanyInfo as b7, type WebsiteSettings as b8, type EnabledItems as b9, type BlogDetailData as bA, type BlogListData as bB, type BlogListItem as bC, type CartItem as bD, type CartSummary as bE, type CartContextType as bF, type ApiResponse as bG, type PaginatedResponse as bH, type ServerFetcherResponse as bI, type ApiListResponse as bJ, type ListQueryParams as bK, type Location as bL, type LocationListResponse as bM, type ApiPriceGroup as bN, type ApiProductRaw as bO, type ProductFiltersParams as bP, type BlogFiltersParams as bQ, type ActiveSocialConnections as ba, type ActiveHotlineConnections as bb, type ActiveTrackingAnalytics as bc, type ProductCategory as bd, type ProductTag as be, type PriceRange as bf, type SortOption as bg, type ProductSize as bh, type ProductPriceGroup as bi, type ProductPrice as bj, type ProductMeasurements as bk, type ProductSpecs as bl, type ProductOption as bm, type ProductVariant as bn, type Product as bo, type ProductFilters as bp, type ProductListItem as bq, type ProductCardProps as br, type BlogCategory as bs, type BlogImage as bt, type BlogUser as bu, type BlogCategoryData as bv, type BlogMetaData as bw, type ResponseMetaData as bx, type Blog as by, type BlogFilters as bz, type AnimationSettings as c, animationFieldDefinitions as d, defaultAnimationSettings as e, type BaseFieldDefinition as f, type TextareaFieldDefinition as g, type BooleanFieldDefinition as h, type CheckboxFieldDefinition as i, type RadioFieldDefinition as j, type RichTextFieldDefinition as k, type FontFieldDefinition as l, type CollectionFieldDefinition as m, type BlogFieldDefinition as n, type ArticleFieldDefinition as o, type PageFieldDefinition as p, type FieldDefinition as q, type SettingValue as r, type Settings as s, FIELD_TYPES as t, type BlockDefinition as u, type BlockInstance as v, type BlockRegistration as w, type BlockComponentProps as x, type TemplateDefinition as y, type SectionSchema as z };