@duongthiu/onex-core 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,1461 @@
+import { ar as RegistryConfig, aA as SectionRegistry, aB as BlockRegistry, O as ComponentDefinition, X as ComponentProps, M as ComponentCategory, W as ComponentRegistration, D as SectionInstance, v as BlockInstance, E as SectionComponentInstance, Q as ComponentInstance, aW as DetectionResult, r as SettingValue, z as SectionSchema, H as SectionComponentProps, y as TemplateDefinition, bF as CartContextType, b8 as WebsiteSettings } from './api-vuL1Eg5L.js';
+export { bb as ActiveHotlineConnections, ba as ActiveSocialConnections, bc as ActiveTrackingAnalytics, a as AnimationEasing, c as AnimationSettings, b as AnimationTrigger, A as AnimationType, bJ as ApiListResponse, bN as ApiPriceGroup, bO as ApiProductRaw, bG as ApiResponse, $ as ApplyScope, a0 as ApplyScopeResult, o as ArticleFieldDefinition, B as BaseEntity, f as BaseFieldDefinition, x as BlockComponentProps, u as BlockDefinition, ax as BlockRegisteredPayload, w as BlockRegistration, ay as BlockUnregisteredPayload, by as Blog, bs as BlogCategory, bv as BlogCategoryData, bA as BlogDetailData, n as BlogFieldDefinition, bz as BlogFilters, bQ as BlogFiltersParams, bt as BlogImage, bB as BlogListData, bC as BlogListItem, bw as BlogMetaData, bu as BlogUser, h as BooleanFieldDefinition, ag as BorderRadius, Z as Breakpoint, ah as Breakpoints, a1 as COMPONENT_CATEGORIES, a2 as COMPONENT_TYPES, bD as CartItem, bE as CartSummary, i as CheckboxFieldDefinition, m as CollectionFieldDefinition, C as ColorFieldDefinition, ad as ColorPalette, b7 as CompanyInfo, ab as ComponentPageDefinition, L as ComponentType, b6 as ContactEmail, a_ as DEFAULT_INSPECTOR_CONFIG, ac as DesignToken, aE as DetectedElement, aC as DetectedSection, aU as DetectionPriority, aV as DetectionStrategy, aQ as DragDropContext, aF as EditableElementRegistry, aM as EditorActions, aN as EditorContextValue, aI as EditorMode, aL as EditorState, aT as ElementMetadata, aD as ElementRegistry, aS as ElementType, b9 as EnabledItems, t as FIELD_TYPES, q as FieldDefinition, F as FieldType, l as FontFieldDefinition, aP as HistoryEntry, b3 as HotlineConnection, b2 as HotlineType, I as ImageFieldDefinition, aY as InlineEditorProps, aX as InlineEditorState, aZ as InspectorConfig, aO as InspectorOverlayState, aR as KeyboardShortcut, bK as ListQueryParams, bL as Location, bM as LocationListResponse, N as NumberFieldDefinition, a5 as PageConfig, p as PageFieldDefinition, a7 as PageListItem, a8 as PageNavItem, aG as PageRegistration, a9 as PageRenderMode, a4 as PageSEO, a6 as PageTemplate, aH as PageTemplateRegistration, a3 as PageType, bH as PaginatedResponse, bf as PriceRange, bo as Product, br as ProductCardProps, bd as ProductCategory, P as ProductFieldDefinition, bp as ProductFilters, bP as ProductFiltersParams, bq as ProductListItem, bk as ProductMeasurements, bm as ProductOption, bj as ProductPrice, bi as ProductPriceGroup, bh as ProductSize, bl as ProductSpecs, be as ProductTag, bn as ProductVariant, j as RadioFieldDefinition, R as RangeFieldDefinition, at as RegistryEvent, az as RegistryEventHandler, as as RegistryEventType, bx as ResponseMetaData, _ as ResponsiveStyles, k as RichTextFieldDefinition, K as SECTION_CATEGORIES, J as SectionCategory, au as SectionRegisteredPayload, G as SectionRegistration, av as SectionUnregisteredPayload, S as SelectFieldDefinition, aK as SelectedElement, aJ as SelectedElementType, bI as ServerFetcherResponse, s as Settings, a$ as SettingsIcon, b1 as SocialConnection, b0 as SocialPlatform, bg as SortOption, af as Spacing, Y as StyleSettings, aw as TemplateRegisteredPayload, T as TextFieldDefinition, g as TextareaFieldDefinition, ai as ThemeConfig, ak as ThemeExport, aa as ThemeLayoutConfig, al as ThemeManifest, am as ThemeModule, aj as ThemePreset, an as ThemeUpload, ap as ThemeValidationError, ao as ThemeValidationResult, aq as ThemeValidationWarning, b5 as TrackingAnalytics, b4 as TrackingPlatform, ae as Typography, U as UrlFieldDefinition, V as VideoFieldDefinition, d as animationFieldDefinitions, e as defaultAnimationSettings } from './api-vuL1Eg5L.js';
+import { ClassValue } from 'clsx';
+import React$1, { ReactNode } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/**
+ * Section Registry Implementation
+ * Hierarchical registry with multi-template support
+ */
+
+/**
+ * Create a new section registry instance
+ */
+declare function createSectionRegistry(config?: RegistryConfig): SectionRegistry;
+/**
+ * Global section registry instance
+ */
+declare const sectionRegistry: SectionRegistry;
+
+/**
+ * Block Registry Implementation
+ * Registry for repeatable block components
+ */
+
+/**
+ * Create a new block registry instance
+ */
+declare function createBlockRegistry(config?: RegistryConfig): BlockRegistry;
+/**
+ * Global block registry instance
+ */
+declare const blockRegistry: BlockRegistry;
+
+/**
+ * Component Registry
+ * Central registry for all component types
+ */
+
+/**
+ * Component Registry Class
+ */
+declare class ComponentRegistry {
+    private components;
+    private categories;
+    private tags;
+    private events;
+    /**
+     * Register a component type
+     */
+    register(type: string, definition: ComponentDefinition, component: React.ComponentType<ComponentProps>, options?: {
+        category?: ComponentCategory;
+        tags?: string[];
+    }): void;
+    /**
+     * Unregister a component type
+     */
+    unregister(type: string): boolean;
+    /**
+     * Get component by type
+     */
+    get(type: string): ComponentRegistration | undefined;
+    /**
+     * Get component definition by type
+     */
+    getDefinition(type: string): ComponentDefinition | undefined;
+    /**
+     * Get component React component by type
+     */
+    getComponent(type: string): React.ComponentType<ComponentProps> | undefined;
+    /**
+     * Get all components
+     */
+    getAll(): Map<string, ComponentRegistration>;
+    /**
+     * Get all component types
+     */
+    getAllTypes(): string[];
+    /**
+     * Get components by category
+     */
+    getByCategory(category: ComponentCategory): ComponentRegistration[];
+    /**
+     * Get components by tag
+     */
+    getByTag(tag: string): ComponentRegistration[];
+    /**
+     * Search components
+     */
+    search(query: string): ComponentRegistration[];
+    /**
+     * Get all categories
+     */
+    getCategories(): ComponentCategory[];
+    /**
+     * Get all tags
+     */
+    getTags(): string[];
+    /**
+     * Check if component type exists
+     */
+    has(type: string): boolean;
+    /**
+     * Get component count
+     */
+    count(): number;
+    /**
+     * Get component count by category
+     */
+    countByCategory(category: ComponentCategory): number;
+    /**
+     * Subscribe to registry events
+     */
+    on(event: string, handler: (...args: unknown[]) => void): void;
+    /**
+     * Unsubscribe from registry events
+     */
+    off(event: string, handler: (...args: unknown[]) => void): void;
+    /**
+     * Clear all components (for testing)
+     */
+    clear(): void;
+}
+declare const componentRegistry: ComponentRegistry;
+
+/**
+ * ID Generation Utilities
+ * Generate unique IDs for pages, sections, and other entities
+ */
+/**
+ * Generate a unique page ID
+ *
+ * @param prefix - Optional prefix (default: 'page')
+ * @returns Unique page ID
+ *
+ * @example
+ * ```ts
+ * const pageId = generatePageId(); // 'page-a3b4c5d6'
+ * const pageId = generatePageId('homepage'); // 'homepage-a3b4c5d6'
+ * ```
+ */
+declare function generatePageId(prefix?: string): string;
+/**
+ * Generate a unique section ID
+ *
+ * @param sectionType - Section type (e.g., 'hero', 'features')
+ * @returns Unique section ID
+ *
+ * @example
+ * ```ts
+ * const sectionId = generateSectionId('hero'); // 'hero-1234567890-a3b4c5d6'
+ * ```
+ */
+declare function generateSectionId(sectionType: string): string;
+/**
+ * Generate a unique block ID
+ *
+ * @param blockType - Block type (e.g., 'text', 'image')
+ * @returns Unique block ID
+ *
+ * @example
+ * ```ts
+ * const blockId = generateBlockId('text'); // 'text-1234567890-a3b4c5d6'
+ * ```
+ */
+declare function generateBlockId(blockType: string): string;
+/**
+ * Generate a URL-friendly handle from a title
+ *
+ * @param title - Page or section title
+ * @returns URL-friendly handle
+ *
+ * @example
+ * ```ts
+ * const handle = generateHandle('My New Page'); // 'my-new-page'
+ * const handle = generateHandle('About Us & Services'); // 'about-us-services'
+ * ```
+ */
+declare function generateHandle(title: string): string;
+/**
+ * Generate a unique theme ID
+ *
+ * @param name - Theme name
+ * @returns Unique theme ID
+ *
+ * @example
+ * ```ts
+ * const themeId = generateThemeId('Dark Mode'); // 'dark-mode-1234567890'
+ * ```
+ */
+declare function generateThemeId(name: string): string;
+/**
+ * Generate a generic unique ID
+ *
+ * @param prefix - Optional prefix (default: 'id')
+ * @returns Unique ID
+ *
+ * @example
+ * ```ts
+ * const id = generateId(); // 'id-1234567890-a3b4c5d6'
+ * const id = generateId('comp'); // 'comp-1234567890-a3b4c5d6'
+ * ```
+ */
+declare function generateId(prefix?: string): string;
+
+/**
+ * Block Finder Utilities
+ * Recursive functions to find, update, and remove blocks at any nesting level
+ */
+
+/**
+ * Recursively find a block by ID in a section's block tree
+ * @param section - The section to search in
+ * @param blockId - The block ID to find
+ * @returns The block if found, undefined otherwise
+ */
+declare function findBlockInSection(section: SectionInstance | null | undefined, blockId: string): BlockInstance | undefined;
+/**
+ * Update a block at any nesting level in a section
+ * @param section - The section containing the block
+ * @param blockId - The block ID to update
+ * @param updates - Partial updates to apply to the block
+ * @returns Updated section with the block modified
+ */
+declare function updateNestedBlock(section: SectionInstance, blockId: string, updates: Partial<BlockInstance>): SectionInstance;
+/**
+ * Remove a block at any nesting level from a section
+ * @param section - The section containing the block
+ * @param blockId - The block ID to remove
+ * @returns Updated section with the block removed
+ */
+declare function removeNestedBlock(section: SectionInstance, blockId: string): SectionInstance;
+/**
+ * Get the path to a block (useful for debugging)
+ * @param section - The section to search in
+ * @param blockId - The block ID to find
+ * @returns Array of block IDs representing the path, or empty array if not found
+ */
+declare function getBlockPath(section: SectionInstance | null | undefined, blockId: string): string[];
+
+/**
+ * Component Finder Utilities
+ * Recursive functions to find components at any nesting level (in sections and blocks)
+ */
+
+/**
+ * Recursively find a component by ID in a section
+ * Searches both direct section components and components nested in blocks
+ * @param section - The section to search in
+ * @param componentId - The component ID to find
+ * @returns The component if found, null otherwise
+ */
+declare function findComponentInSection(section: SectionInstance | null | undefined, componentId: string): SectionComponentInstance | null;
+/**
+ * Get the path to a component (useful for debugging)
+ * @param section - The section to search in
+ * @param componentId - The component ID to find
+ * @returns Object with the path information, or null if not found
+ */
+declare function getComponentPath(section: SectionInstance | null | undefined, componentId: string): {
+    sectionId: string;
+    blockPath: string[];
+    componentId: string;
+} | null;
+
+/**
+ * Component Updater Utilities
+ * Recursive functions to update components at any nesting level (in sections and blocks)
+ */
+
+/**
+ * Update a component at any nesting level in a section
+ * Searches both direct section components and components nested in blocks
+ * @param section - The section containing the component
+ * @param componentId - The component ID to update
+ * @param updates - Partial updates to apply to the component
+ * @returns Updated section with the component modified
+ */
+declare function updateNestedComponent(section: SectionInstance, componentId: string, updates: Partial<SectionComponentInstance>): SectionInstance;
+
+/**
+ * Section Helper Utilities
+ * Auto-rendering utilities for sections with component grouping and slot-based layouts
+ */
+
+/**
+ * Sort components by order field
+ */
+declare function sortComponents<T extends ComponentInstance | SectionComponentInstance>(components: T[]): T[];
+/**
+ * Filter enabled components only
+ */
+declare function filterEnabledComponents<T extends ComponentInstance | SectionComponentInstance>(components: T[]): T[];
+/**
+ * Get components sorted and filtered
+ */
+declare function getActiveComponents<T extends ComponentInstance | SectionComponentInstance>(components: T[]): T[];
+/**
+ * Slot configuration for grouping components
+ */
+interface SlotConfig {
+    [slotName: string]: string[];
+}
+/**
+ * Grouped components by slot
+ */
+interface GroupedComponents<T extends ComponentInstance | SectionComponentInstance = ComponentInstance> {
+    slots: Record<string, T[]>;
+    ungrouped: T[];
+}
+/**
+ * Group components by slot based on their types
+ * Useful for layout-based rendering (header, content, footer, etc.)
+ *
+ * @example
+ * ```tsx
+ * const slotConfig = {
+ *   header: ['heading', 'badge'],
+ *   content: ['paragraph', 'image'],
+ *   actions: ['button']
+ * };
+ * const { slots, ungrouped } = groupBySlot(components, slotConfig);
+ * ```
+ */
+declare function groupBySlot<T extends ComponentInstance | SectionComponentInstance>(components: T[], slotConfig: SlotConfig): GroupedComponents<T>;
+/**
+ * Get components by type
+ * Useful for finding specific component types in a section
+ *
+ * @example
+ * ```tsx
+ * const headings = getComponentsByType(components, 'heading');
+ * const buttons = getComponentsByType(components, ['button', 'link']);
+ * ```
+ */
+declare function getComponentsByType<T extends ComponentInstance | SectionComponentInstance>(components: T[], types: string | string[]): T[];
+/**
+ * Get first component by type
+ * Useful for getting a specific component like the main heading
+ *
+ * @example
+ * ```tsx
+ * const heading = getFirstComponentByType(components, 'heading');
+ * ```
+ */
+declare function getFirstComponentByType<T extends ComponentInstance | SectionComponentInstance>(components: T[], types: string | string[]): T | undefined;
+/**
+ * Check if section has any components of given type
+ */
+declare function hasComponentType<T extends ComponentInstance | SectionComponentInstance>(components: T[], types: string | string[]): boolean;
+/**
+ * Sort blocks by order field
+ */
+declare function sortBlocks(blocks: BlockInstance[]): BlockInstance[];
+/**
+ * Filter enabled blocks only
+ */
+declare function filterEnabledBlocks(blocks: BlockInstance[]): BlockInstance[];
+/**
+ * Get blocks sorted and filtered
+ */
+declare function getActiveBlocks(blocks: BlockInstance[]): BlockInstance[];
+/**
+ * Count enabled items (components or blocks)
+ */
+declare function countEnabledItems<T extends {
+    enabled?: boolean;
+}>(items: T[]): number;
+/**
+ * Check if array has any enabled items
+ */
+declare function hasEnabledItems<T extends {
+    enabled?: boolean;
+}>(items: T[] | undefined): boolean;
+
+/**
+ * Get display label for a detection result
+ * Formats section/block/component names for the inspector overlay
+ */
+declare function getElementLabel(result: DetectionResult): string;
+/**
+ * Get color for a detection type
+ * Returns the appropriate outline color from the inspector config
+ */
+declare function getSelectionColor(type: string): string;
+/**
+ * Format a kebab-case name to Title Case
+ * e.g., "feature-card" → "Feature Card"
+ */
+declare function formatBlockName(name: string): string;
+
+/**
+ * Class Name Utility
+ * Merge Tailwind CSS classes with proper conflict resolution
+ */
+
+/**
+ * Combines class names with Tailwind CSS conflict resolution
+ *
+ * @param inputs - Class names to merge
+ * @returns Merged class string
+ *
+ * @example
+ * cn("px-2 py-1", "px-4") // => "py-1 px-4"
+ * cn("text-red-500", condition && "text-blue-500") // => "text-blue-500" (if condition is true)
+ */
+declare function cn(...inputs: ClassValue[]): string;
+
+/**
+ * Data Adapters
+ * Convert between different data formats for compatibility
+ */
+
+/**
+ * Adapt a SectionComponentInstance to a full ComponentInstance
+ * so it can be rendered via the component registry.
+ *
+ * - Ensures content/style objects always exist
+ * - Preserves ordering and metadata
+ *
+ * @param component - Section component instance to adapt
+ * @returns Full component instance ready for rendering
+ *
+ * @example
+ * const sectionComp = { id: "1", type: "heading", settings: { text: "Hello" } };
+ * const fullComp = toComponentInstance(sectionComp);
+ * // fullComp.content = { text: "Hello" }
+ * // fullComp.style = {}
+ */
+declare function toComponentInstance(component: SectionComponentInstance): ComponentInstance;
+
+/**
+ * Section Helper Types
+ * Type definitions for section validation and value extraction
+ */
+
+/**
+ * Validation error for a single field
+ */
+interface ValidationError$1 {
+    /** Field ID that failed validation */
+    field: string;
+    /** Current value that failed */
+    value: SettingValue;
+    /** Human-readable error message */
+    message: string;
+    /** Expected/allowed values (for select/radio fields) */
+    allowedValues?: string[];
+}
+/**
+ * Validation result
+ */
+interface ValidationResult$1 {
+    /** Whether all fields are valid */
+    valid: boolean;
+    /** List of validation errors */
+    errors: ValidationError$1[];
+}
+/**
+ * Section values returned by getSectionValues()
+ */
+interface SectionValues {
+    /** All section settings with auto-type conversion */
+    settings: Record<string, SettingValue>;
+    /** Whether all values passed validation */
+    isValid: boolean;
+    /** List of validation errors (empty if valid) */
+    errors: ValidationError$1[];
+}
+
+/**
+ * Section Helpers - Validation
+ * Validates section field values against schema definitions
+ * @module utils/section/validation
+ */
+
+/**
+ * Validate all settings in a section
+ *
+ * @param section - Section instance
+ * @param schema - Section schema
+ * @returns Validation result with errors
+ * @internal
+ */
+declare function validateSettings(section: SectionInstance, schema: SectionSchema): ValidationResult$1;
+/**
+ * Validate entire section (settings)
+ *
+ * @param section - Section instance
+ * @param schema - Section schema
+ * @returns Validation result
+ */
+declare function validateSection(section: SectionInstance, schema: SectionSchema): ValidationResult$1;
+
+/**
+ * Section Helpers - Main API
+ *
+ * Provides schema-driven validation and value extraction for sections.
+ * Auto-extracts all fields from schema with type detection and validation.
+ *
+ * @example
+ * ```typescript
+ * import { getSectionValues } from '@onex/core';
+ *
+ * export function MySection({ section, schema }: SectionComponentProps) {
+ *   const { settings } = getSectionValues(section, schema);
+ *
+ *   // Direct property access - auto-typed!
+ *   const { title, subtitle, backgroundColor } = settings;
+ *
+ *   return <div style={{ backgroundColor }}>{title}</div>;
+ * }
+ * ```
+ *
+ * @module utils/section
+ */
+
+/**
+ * Get all section values with validation and auto-type conversion
+ *
+ * This is the primary API for sections. It:
+ * - Auto-extracts ALL fields from schema (no need to specify field names)
+ * - Validates runtime values against schema definitions
+ * - Auto-converts types based on field type (text→string, number→number, etc.)
+ * - Falls back to schema defaults for missing/invalid values
+ * - Provides direct property access: settings.title, settings.backgroundColor
+ *
+ * @param section - Section instance (runtime data)
+ * @param schema - Section schema (definition)
+ * @returns Object with settings, isValid, and errors
+ *
+ * @example
+ * ```typescript
+ * const { settings } = getSectionValues(section, schema);
+ *
+ * // Direct property access - auto-typed!
+ * const title = settings.title;           // string (auto-detected from schema)
+ * const enabled = settings.enabled;       // boolean (auto-detected from schema)
+ * const padding = settings.padding;       // number (auto-detected from schema)
+ *
+ * // Or destructure
+ * const { title, subtitle, backgroundColor, padding } = settings;
+ * ```
+ */
+declare function getSectionValues(section: SectionInstance, schema: SectionSchema): SectionValues;
+
+/**
+ * Component Helpers - Type Definitions
+ * @module utils/component/types
+ */
+
+/**
+ * Validation error details
+ */
+interface ValidationError {
+    /** Field ID that failed validation */
+    field: string;
+    /** The invalid value */
+    value: SettingValue;
+    /** Human-readable error message */
+    message: string;
+    /** Allowed values (for select/radio fields) */
+    allowedValues?: SettingValue[];
+}
+/**
+ * Validation result
+ */
+interface ValidationResult {
+    /** Whether validation passed */
+    valid: boolean;
+    /** List of validation errors (empty if valid) */
+    errors: ValidationError[];
+}
+/**
+ * Component values with auto-typed property access
+ */
+interface ComponentValues {
+    /** Content values with auto-type conversion */
+    content: Record<string, SettingValue>;
+    /** Style values with auto-type conversion */
+    style: Record<string, SettingValue>;
+    /** Whether all values are valid */
+    isValid: boolean;
+    /** Validation errors (empty if valid) */
+    errors: ValidationError[];
+}
+
+/**
+ * Component Helpers - Validation
+ * Validates component values against schema definitions
+ * @module utils/component/validation
+ */
+
+/**
+ * Validate component content against schema
+ */
+declare function validateContent(component: ComponentInstance, definition: ComponentDefinition): ValidationResult;
+/**
+ * Validate component style against schema
+ */
+declare function validateStyle(component: ComponentInstance, definition: ComponentDefinition): ValidationResult;
+/**
+ * Validate entire component instance against its definition
+ */
+declare function validateComponent(component: ComponentInstance, definition: ComponentDefinition): ValidationResult;
+
+/**
+ * Component Helpers - Main API
+ *
+ * Provides schema-driven validation and value extraction for components.
+ * Auto-extracts all fields from schema with type detection and validation.
+ *
+ * @example
+ * ```typescript
+ * import { getComponentValues } from '@onex/core';
+ *
+ * export function MyComponent({ component, definition }: ComponentProps) {
+ *   const { content, style } = getComponentValues(component, definition);
+ *
+ *   // Direct property access - auto-typed!
+ *   const { text, url } = content;
+ *   const { variant, size } = style;
+ *
+ *   return <div>{text}</div>;
+ * }
+ * ```
+ *
+ * @module utils/component
+ */
+
+/**
+ * Get all component values with validation and auto-type conversion
+ *
+ * This is the primary API for components. It:
+ * - Auto-extracts ALL fields from schema (no need to specify field names)
+ * - Validates runtime values against schema definitions
+ * - Auto-converts types based on field type (text→string, number→number, etc.)
+ * - Falls back to schema defaults for missing/invalid values
+ * - Provides direct property access: content.text, style.variant
+ *
+ * @param component - Component instance (runtime data)
+ * @param definition - Component definition (schema)
+ * @returns Object with content, style, isValid, and errors
+ *
+ * @example
+ * ```typescript
+ * const { content, style } = getComponentValues(component, definition);
+ *
+ * // Direct property access - auto-typed!
+ * const text = content.text;       // string (auto-detected from schema)
+ * const enabled = content.enabled; // boolean (auto-detected from schema)
+ * const variant = style.variant;   // string (auto-detected from schema)
+ *
+ * // Or destructure
+ * const { text, url, target } = content;
+ * const { variant, size } = style;
+ * ```
+ */
+declare function getComponentValues(component: ComponentInstance, definition: ComponentDefinition): ComponentValues;
+
+interface ComponentRendererProps {
+    /** Component instance to render */
+    instance: ComponentInstance;
+    /** Section ID (required for click detection) */
+    sectionId?: string;
+    /** Whether in edit mode */
+    isEditing?: boolean;
+    /** Additional wrapper classes */
+    className?: string;
+    /** Fallback when component not found */
+    fallback?: React$1.ReactNode;
+}
+/**
+ * Render a single component instance
+ */
+declare function ComponentRenderer({ instance, sectionId, isEditing, className, fallback, }: ComponentRendererProps): React$1.ReactElement | null;
+/**
+ * Render multiple component instances
+ */
+interface ComponentListRendererProps {
+    /** Component instances to render */
+    instances: ComponentInstance[];
+    /** Section ID (required for click detection) */
+    sectionId?: string;
+    /** Whether in edit mode */
+    isEditing?: boolean;
+    /** Container class */
+    containerClassName?: string;
+    /** Item wrapper class */
+    itemClassName?: string;
+}
+declare function ComponentListRenderer({ instances, sectionId, isEditing, containerClassName, itemClassName, }: ComponentListRendererProps): React$1.ReactElement;
+/**
+ * Hook to get a component registration
+ */
+declare function useComponentRegistration(componentType: string): ComponentRegistration | undefined;
+/**
+ * Hook to render a component instance
+ */
+declare function useComponentInstance(instance: ComponentInstance | undefined): {
+    Component: React$1.ComponentType<ComponentProps>;
+    definition: ComponentDefinition;
+    instance: ComponentInstance;
+} | null;
+
+/**
+ * Block Renderer Utility
+ * Recursive renderer for block instances with support for nested blocks and components
+ */
+
+interface BlockRendererProps {
+    /** Block instance to render */
+    block: BlockInstance;
+    /** Section ID (for context) */
+    sectionId?: string;
+    /** Whether in edit mode */
+    isEditing?: boolean;
+    /** Additional data (e.g., website settings) */
+    data?: Record<string, unknown>;
+    /** Additional wrapper classes */
+    className?: string;
+    /** Fallback when block not found */
+    fallback?: React$1.ReactNode;
+}
+/**
+ * Render a single block instance with recursive support
+ * Handles both registered block components and generic fallback
+ */
+declare function BlockRenderer({ block, sectionId, isEditing, data, className, fallback, }: BlockRendererProps): React$1.ReactElement | null;
+interface BlockListRendererProps {
+    /** Array of block instances to render */
+    blocks: BlockInstance[];
+    /** Section ID (for context) */
+    sectionId?: string;
+    /** Whether in edit mode */
+    isEditing?: boolean;
+    /** Additional data (e.g., website settings) */
+    data?: Record<string, unknown>;
+    /** Container class name */
+    containerClassName?: string;
+    /** Individual block class name */
+    blockClassName?: string;
+}
+/**
+ * Render a list of blocks with auto-sorting
+ * Automatically sorts by order field and filters enabled blocks
+ */
+declare function BlockListRenderer({ blocks, sectionId, isEditing, data, containerClassName, blockClassName, }: BlockListRendererProps): React$1.ReactElement | null;
+/**
+ * Simple helper to render a block
+ * Convenience wrapper around BlockRenderer
+ */
+declare function renderBlock(block: BlockInstance, isEditing?: boolean, className?: string, sectionId?: string): React$1.ReactElement | null;
+
+/**
+ * Section Renderer
+ * Universal renderer for section instances with theme components
+ */
+
+interface SectionRendererProps {
+    /** The section instance to render */
+    section: SectionInstance;
+    /** The React component to render the section */
+    Component: React$1.ComponentType<SectionComponentProps>;
+    /** Section schema for metadata */
+    schema?: SectionSchema;
+    /** Template definition */
+    template?: TemplateDefinition;
+    /** Whether in editing mode */
+    isEditing?: boolean;
+    /** Additional data to pass to the component */
+    data?: Record<string, unknown>;
+    /** Fallback component if rendering fails */
+    fallback?: React$1.ReactNode;
+    /** Additional className for the wrapper */
+    className?: string;
+}
+/**
+ * Render a section with proper wrapping and error handling
+ */
+declare function SectionRenderer({ section, Component, schema, template, isEditing, data, fallback, className, }: SectionRendererProps): React$1.ReactElement | null;
+interface SectionListRendererProps {
+    /** Array of sections to render */
+    sections: SectionInstance[];
+    /** Function to get component for a section */
+    getComponent: (sectionType: string, template: string) => {
+        Component: React$1.ComponentType<SectionComponentProps>;
+        schema?: SectionSchema;
+        template?: TemplateDefinition;
+    } | null;
+    /** Whether in editing mode */
+    isEditing?: boolean;
+    /** Additional data to pass to components */
+    data?: Record<string, unknown>;
+    /** Fallback for missing sections */
+    fallback?: (section: SectionInstance) => React$1.ReactNode;
+    /** Additional className for wrappers */
+    className?: string;
+}
+/**
+ * Render a list of sections with automatic filtering and sorting
+ */
+declare function SectionListRenderer({ sections, getComponent, isEditing, data, fallback, className, }: SectionListRendererProps): React$1.ReactElement;
+/**
+ * Helper function to render a single section (non-component version)
+ * Useful for server components or static rendering
+ */
+declare function renderSection(props: SectionRendererProps): React$1.ReactElement | null;
+
+declare function CartProvider({ children }: {
+    children: React$1.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access cart context
+ */
+declare function useCart(): CartContextType;
+
+interface ThemeContextValue {
+    themeId: string;
+    setThemeId: (id: string) => void;
+}
+interface ThemeContextProviderProps {
+    children: React$1.ReactNode;
+    themeId: string;
+}
+declare function ThemeContextProvider({ children, themeId: initialThemeId, }: ThemeContextProviderProps): react_jsx_runtime.JSX.Element;
+declare function useThemeContext(): ThemeContextValue;
+
+/**
+ * Viewport Context
+ * Provides viewport mode for editor preview responsiveness
+ */
+type ViewportMode = "desktop" | "tablet" | "mobile";
+interface ViewportContextType {
+    /** Whether in editor mode */
+    isEditing: boolean;
+    /** Current viewport mode */
+    viewportMode: ViewportMode;
+}
+declare function ViewportProvider({ children, isEditing, viewportMode, }: {
+    children: React.ReactNode;
+    isEditing: boolean;
+    viewportMode: ViewportMode;
+}): react_jsx_runtime.JSX.Element;
+declare function useViewport(): ViewportContextType;
+/**
+ * Hook to get responsive class based on viewport mode
+ * Returns mobile class when in mobile preview, tablet class when in tablet preview, etc.
+ */
+declare function useResponsiveClass(classes: {
+    mobile: string;
+    tablet: string;
+    desktop: string;
+}): string;
+
+/**
+ * Generic page data structure
+ */
+interface PageData {
+    /** Website settings (social connections, hotlines, etc.) */
+    websiteSettings?: WebsiteSettings;
+    /** Any other dynamic data needed by the page */
+    [key: string]: unknown;
+}
+/**
+ * Page Data Provider Props
+ */
+interface PageDataProviderProps {
+    /** Server-fetched data to provide to children */
+    data?: PageData;
+    /** Child components */
+    children: React$1.ReactNode;
+}
+/**
+ * Page Data Provider Component
+ * Wraps pages/components to provide server-fetched data via context
+ *
+ * @example
+ * ```tsx
+ * <PageDataProvider data={{ websiteSettings }}>
+ *   <YourPage />
+ * </PageDataProvider>
+ * ```
+ */
+declare function PageDataProvider({ data, children, }: PageDataProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access page data
+ * Returns all page data provided by PageDataProvider
+ *
+ * @throws Error if used outside PageDataProvider
+ *
+ * @example
+ * ```tsx
+ * const pageData = usePageData();
+ * const customData = pageData.myCustomField;
+ * ```
+ */
+declare function usePageData(): PageData;
+/**
+ * Hook to access website settings from page data
+ * Convenience hook that extracts websiteSettings from page data
+ *
+ * @returns WebsiteSettings object (empty object if not available)
+ *
+ * @example
+ * ```tsx
+ * function MyBlock() {
+ *   const websiteSettings = useWebsiteSettings();
+ *   const socials = useSocialConnections(websiteSettings);
+ *   // ...
+ * }
+ * ```
+ */
+declare function useWebsiteSettings(): WebsiteSettings;
+
+interface GridContainerProps {
+    /** Content to render inside the container */
+    children: ReactNode;
+    /** Additional CSS classes */
+    className?: string;
+    /** HTML element to render as */
+    as?: "div" | "section" | "header" | "footer" | "main";
+}
+/**
+ * Grid Container Component
+ * Implements a 12-column grid system with proper gutters and max-width
+ * All content should be wrapped in this container for consistent layout
+ *
+ * Breakpoints and padding:
+ * - Mobile (< 768px): 20px padding (16px + 4px gutter)
+ * - Tablet (768px - 1023px): 32px padding
+ * - Desktop (1024px - 1279px): 40px padding
+ * - Large (1280px - 1919px): 140px padding
+ * - XL (>= 1920px): max 1640px content width (1920px - 280px padding)
+ *
+ * @example
+ * ```tsx
+ * <GridContainer>
+ *   <h1>My Content</h1>
+ * </GridContainer>
+ * ```
+ */
+declare function GridContainer({ children, className, as: Component, }: GridContainerProps): react_jsx_runtime.JSX.Element;
+interface FullWidthSectionProps {
+    /** Content to render inside the section */
+    children: ReactNode;
+    /** Additional CSS classes */
+    className?: string;
+    /** Background color (can be any valid CSS color) */
+    backgroundColor?: string;
+}
+/**
+ * Full Width Container (for backgrounds that extend full width)
+ * Content inside should still use GridContainer for proper content width
+ *
+ * @example
+ * ```tsx
+ * <FullWidthSection backgroundColor="#f5f5f5">
+ *   <GridContainer>
+ *     <h1>Full-width background, constrained content</h1>
+ *   </GridContainer>
+ * </FullWidthSection>
+ * ```
+ */
+declare function FullWidthSection({ children, className, backgroundColor, }: FullWidthSectionProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Heading Component
+ * Renders text headings (H1-H6) with customizable typography
+ *
+ * ✅ Now uses component-helpers for auto-typed values with validation
+ */
+
+declare function HeadingComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Heading Component Schema
+ * Text heading (H1-H6) with typography controls
+ */
+
+declare const headingComponentDefinition: ComponentDefinition;
+
+/**
+ * Paragraph Component
+ * Renders text paragraph with typography controls
+ *
+ * ✅ Now uses component-helpers for auto-typed values with validation
+ */
+
+declare function ParagraphComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Paragraph Component Schema
+ * Text paragraph with typography controls
+ */
+
+declare const paragraphComponentDefinition: ComponentDefinition;
+
+/**
+ * Button Component
+ * Renders clickable button with link
+ *
+ * ✅ Framework-agnostic version using native <a> tag
+ * Note: Apps using Next.js should wrap with Link component in their theme override
+ */
+
+declare function ButtonComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Button Component Schema
+ * Clickable button with link and styling options
+ */
+
+declare const buttonComponentDefinition: ComponentDefinition;
+
+/**
+ * Link Component
+ * Renders text hyperlink
+ *
+ * ✅ Framework-agnostic version using native <a> tag
+ */
+
+declare function LinkComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Link Component Schema
+ * Text link with styling options
+ */
+
+declare const linkComponentDefinition: ComponentDefinition;
+
+/**
+ * Divider Component
+ * Horizontal line separator with optional center text
+ *
+ * ✅ Uses Radix UI Separator primitive
+ */
+
+declare function DividerComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Divider Component Schema
+ * Horizontal line separator
+ */
+
+declare const dividerComponentDefinition: ComponentDefinition;
+
+/**
+ * Spacer Component
+ * Vertical spacing element
+ *
+ * ✅ Framework-agnostic spacing component
+ */
+
+declare function SpacerComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Spacer Component Schema
+ * Empty vertical space for layout
+ */
+
+declare const spacerComponentDefinition: ComponentDefinition;
+
+/**
+ * Quote Component
+ * Blockquote with optional citation
+ *
+ * ✅ Framework-agnostic blockquote component
+ */
+
+declare function QuoteComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Quote Component Schema
+ * Blockquote with optional citation and styling
+ */
+
+declare const quoteComponentDefinition: ComponentDefinition;
+
+/**
+ * Badge Component
+ * Small colored label or tag
+ *
+ * ✅ Standalone badge component with shadcn-style variants
+ */
+
+declare function BadgeComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Badge Component Schema
+ * Small colored label or tag
+ */
+
+declare const badgeComponentDefinition: ComponentDefinition;
+
+/**
+ * Image Component
+ * Renders image with optional caption and link
+ *
+ * ✅ Framework-agnostic version using native <img> tag
+ */
+
+declare function ImageComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Image Component Schema
+ * Image with alt text, sizing, and styling options
+ */
+
+declare const imageComponentDefinition: ComponentDefinition;
+
+/**
+ * Icon Component
+ * Displays icon from Lucide icon library
+ *
+ * ✅ Uses lucide-react (peer dependency)
+ */
+
+declare function IconComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Icon Component Schema
+ * Displays icon from icon library
+ */
+
+declare const iconComponentDefinition: ComponentDefinition;
+
+/**
+ * Video Component
+ * Embeds video from YouTube, Vimeo, or self-hosted
+ *
+ * ✅ Framework-agnostic video component
+ */
+
+declare function VideoComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Video Component Schema
+ * Embeds video from YouTube, Vimeo, or self-hosted
+ */
+
+declare const videoComponentDefinition: ComponentDefinition;
+
+/**
+ * List Component
+ * Renders ordered or unordered list
+ *
+ * ✅ Framework-agnostic list component
+ */
+
+declare function ListComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * List Component Schema
+ * Ordered or unordered list with customizable items
+ */
+
+declare const listComponentDefinition: ComponentDefinition;
+
+/**
+ * Container Component
+ * Wrapper element for grouping content
+ *
+ * ✅ Framework-agnostic container component
+ */
+
+declare function ContainerComponent({ component, definition, sectionId, isEditing, className, children, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Container Component Schema
+ * Wrapper element for grouping content with layout controls
+ */
+
+declare const containerComponentDefinition: ComponentDefinition;
+
+/**
+ * Grid Component
+ * CSS Grid layout container
+ *
+ * ✅ Framework-agnostic grid component
+ */
+
+declare function GridComponent({ component, definition, sectionId, isEditing, className, children, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Grid Component Schema
+ * CSS Grid layout container
+ */
+
+declare const gridComponentDefinition: ComponentDefinition;
+
+/**
+ * Columns Component
+ * Flexbox column layout container
+ *
+ * ✅ Framework-agnostic columns component
+ */
+
+declare function ColumnsComponent({ component, definition, sectionId, isEditing, className, children, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Columns Component Schema
+ * Flexbox column layout container
+ */
+
+declare const columnsComponentDefinition: ComponentDefinition;
+
+/**
+ * Card Component
+ * Container with border, shadow, and padding
+ *
+ * ✅ Framework-agnostic card component
+ */
+
+declare function CardComponent({ component, definition, sectionId, isEditing, className, children, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Card Component Schema
+ * Container with border, shadow, and padding
+ */
+
+declare const cardComponentDefinition: ComponentDefinition;
+
+/**
+ * Gallery Component
+ * Image gallery with grid layout
+ *
+ * ✅ Framework-agnostic gallery component
+ */
+
+declare function GalleryComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Gallery Component Schema
+ * Image gallery with grid layout
+ */
+
+declare const galleryComponentDefinition: ComponentDefinition;
+
+/**
+ * Input Component
+ * Text input field for forms
+ *
+ * ✅ Framework-agnostic input component
+ */
+
+declare function InputComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Input Component Schema
+ * Text input field for forms
+ */
+
+declare const inputComponentDefinition: ComponentDefinition;
+
+/**
+ * Textarea Component
+ * Multi-line text input for forms
+ *
+ * ✅ Framework-agnostic textarea using Radix UI Label
+ */
+
+declare function TextareaComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Textarea Component Schema
+ * Multi-line text input for forms
+ */
+
+declare const textareaComponentDefinition: ComponentDefinition;
+
+/**
+ * Checkbox Component
+ * Checkbox input for forms
+ *
+ * ✅ Framework-agnostic checkbox using Radix UI primitives
+ */
+
+declare function CheckboxComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Checkbox Component Schema
+ * Checkbox input for forms
+ */
+
+declare const checkboxComponentDefinition: ComponentDefinition;
+
+/**
+ * Select Component
+ * Dropdown select input for forms
+ *
+ * ✅ Framework-agnostic select using Radix UI primitives
+ */
+
+declare function SelectComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Select Component Schema
+ * Dropdown select input for forms
+ */
+
+declare const selectComponentDefinition: ComponentDefinition;
+
+/**
+ * Rating Component
+ * Star rating display
+ *
+ * ✅ Now uses component-helpers for auto-typed values with validation
+ */
+
+declare function RatingComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Rating Component Schema
+ * Star rating display
+ */
+
+declare const ratingComponentDefinition: ComponentDefinition;
+
+/**
+ * Progress Component
+ * Progress bar indicator
+ *
+ * ✅ Now uses component-helpers for auto-typed values with validation
+ * ✅ Extends shadcn Progress component (Radix-based)
+ */
+
+declare function ProgressComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Progress Component Schema
+ * Progress bar indicator
+ */
+
+declare const progressComponentDefinition: ComponentDefinition;
+
+/**
+ * Alert Component
+ * Alert/notification message box
+ *
+ * ✅ Now uses component-helpers for auto-typed values with validation
+ * ✅ Extends shadcn Alert component
+ */
+
+declare function AlertComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Alert Component Schema
+ * Alert/notification message box
+ */
+
+declare const alertComponentDefinition: ComponentDefinition;
+
+/**
+ * Accordion Component
+ * Collapsible content panels
+ *
+ * ✅ Now uses component-helpers for auto-typed values with validation
+ */
+
+declare function AccordionComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Accordion Component Schema
+ * Collapsible content panels
+ */
+
+declare const accordionComponentDefinition: ComponentDefinition;
+
+/**
+ * Tabs Component
+ * Tabbed interface for content
+ *
+ * ✅ Now uses component-helpers for auto-typed values with validation
+ */
+
+declare function TabsComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Tabs Component Schema
+ * Tabbed interface for content
+ */
+
+declare const tabsComponentDefinition: ComponentDefinition;
+
+/**
+ * Timer Component
+ * Countdown timer
+ *
+ * ✅ Now uses component-helpers for auto-typed values with validation
+ */
+
+declare function TimerComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Timer Component Schema
+ * Countdown timer
+ */
+
+declare const timerComponentDefinition: ComponentDefinition;
+
+/**
+ * Table Component
+ * Data table display
+ *
+ * ✅ Now uses component-helpers for auto-typed values with validation
+ */
+
+declare function TableComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Table Component Schema
+ * Data table display
+ */
+
+declare const tableComponentDefinition: ComponentDefinition;
+
+/**
+ * Map Component
+ * Embedded Google Maps
+ */
+
+declare function MapComponent({ component, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Map Component Schema
+ * Google Maps embed
+ */
+
+declare const mapComponentDefinition: ComponentDefinition;
+
+/**
+ * Code Component
+ * Code block display
+ *
+ * ✅ Now uses component-helpers for auto-typed values with validation
+ */
+
+declare function CodeComponent({ component, definition, sectionId, isEditing, className, }: ComponentProps): React$1.ReactElement;
+
+/**
+ * Code Component Schema
+ * Code block with syntax highlighting
+ */
+
+declare const codeComponentDefinition: ComponentDefinition;
+
+/**
+ * @onex/core/client - Client-Safe Exports
+ *
+ * This entry point exports only client-safe code that can be used in:
+ * - Client Components ("use client")
+ * - Server Components
+ * - Shared utilities
+ *
+ * Does NOT include:
+ * - ThemeRegistryManager (server-only, uses fs/promises)
+ */
+declare const version = "0.1.0";
+
+export { AccordionComponent, AlertComponent, BadgeComponent, BlockInstance, BlockListRenderer, type BlockListRendererProps, BlockRegistry, BlockRenderer, type BlockRendererProps, ButtonComponent, CardComponent, CartContextType, CartProvider, CheckboxComponent, CodeComponent, ColumnsComponent, ComponentCategory, ComponentDefinition, ComponentInstance, ComponentListRenderer, type ComponentListRendererProps, ComponentProps, ComponentRegistration, ComponentRegistry, ComponentRenderer, type ComponentRendererProps, type ValidationError as ComponentValidationError, type ValidationResult as ComponentValidationResult, type ComponentValues, ContainerComponent, DetectionResult, DividerComponent, FullWidthSection, type FullWidthSectionProps, GalleryComponent, GridComponent, GridContainer, type GridContainerProps, type GroupedComponents, HeadingComponent, IconComponent, ImageComponent, InputComponent, LinkComponent, ListComponent, MapComponent, type PageData, PageDataProvider, type PageDataProviderProps, ParagraphComponent, ProgressComponent, QuoteComponent, RatingComponent, RegistryConfig, SectionComponentInstance, SectionComponentProps, SectionInstance, SectionListRenderer, type SectionListRendererProps, SectionRegistry, SectionRenderer, type SectionRendererProps, SectionSchema, type SectionValues, SelectComponent, SettingValue, type SlotConfig, SpacerComponent, TableComponent, TabsComponent, TemplateDefinition, TextareaComponent, ThemeContextProvider, type ThemeContextProviderProps, TimerComponent, type ValidationError$1 as ValidationError, type ValidationResult$1 as ValidationResult, VideoComponent, type ViewportMode, ViewportProvider, WebsiteSettings, accordionComponentDefinition, alertComponentDefinition, badgeComponentDefinition, blockRegistry, buttonComponentDefinition, cardComponentDefinition, checkboxComponentDefinition, cn, codeComponentDefinition, columnsComponentDefinition, componentRegistry, containerComponentDefinition, countEnabledItems, createBlockRegistry, createSectionRegistry, dividerComponentDefinition, filterEnabledBlocks, filterEnabledComponents, findBlockInSection, findComponentInSection, formatBlockName, galleryComponentDefinition, generateBlockId, generateHandle, generateId, generatePageId, generateSectionId, generateThemeId, getActiveBlocks, getActiveComponents, getBlockPath, getComponentPath, getComponentValues, getComponentsByType, getElementLabel, getFirstComponentByType, getSectionValues, getSelectionColor, gridComponentDefinition, groupBySlot, hasComponentType, hasEnabledItems, headingComponentDefinition, iconComponentDefinition, imageComponentDefinition, inputComponentDefinition, linkComponentDefinition, listComponentDefinition, mapComponentDefinition, paragraphComponentDefinition, progressComponentDefinition, quoteComponentDefinition, ratingComponentDefinition, removeNestedBlock, renderBlock, renderSection, sectionRegistry, selectComponentDefinition, sortBlocks, sortComponents, spacerComponentDefinition, tableComponentDefinition, tabsComponentDefinition, textareaComponentDefinition, timerComponentDefinition, toComponentInstance, updateNestedBlock, updateNestedComponent, useCart, useComponentInstance, useComponentRegistration, usePageData, useResponsiveClass, useThemeContext, useViewport, useWebsiteSettings, validateComponent, validateContent, validateSection, validateSettings, validateStyle, version, videoComponentDefinition };