@kustomizer/visual-editor 0.0.1

package/types/kustomizer-visual-editor.d.ts

@@ -0,0 +1,2235 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Type, EnvironmentProviders, OnInit, OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as _ngrx_store from '@ngrx/store';
+import * as _kustomizer_visual_editor from '@kustomizer/visual-editor';
+import { SafeHtml } from '@angular/platform-browser';
+import { Session, User, SupabaseClient } from '@supabase/supabase-js';
+import { CanActivateFn } from '@angular/router';
+
+/**
+ * Navigation target for the visual editor
+ */
+type VisualEditorNavigationTarget = {
+    type: 'page-list';
+} | {
+    type: 'page-edit';
+    pageId: string;
+} | {
+    type: 'page-preview';
+    pageId: string;
+};
+/**
+ * Confirmation dialog options
+ */
+interface ConfirmDialogOptions {
+    title: string;
+    message: string;
+    confirmText?: string;
+    cancelText?: string;
+}
+/**
+ * Abstract navigation service that consumers can implement
+ * to customize how the visual editor navigates between views
+ */
+declare abstract class VisualEditorNavigation {
+    /**
+     * Navigate to a target within the editor context
+     */
+    abstract navigate(target: VisualEditorNavigationTarget): void;
+    /**
+     * Show a confirmation dialog
+     * Returns Observable<boolean> to support async dialogs (e.g., Material Dialog)
+     */
+    abstract confirm(options: ConfirmDialogOptions): Observable<boolean>;
+    /**
+     * Get the current page ID from the navigation context
+     * Returns null if not on a page edit route
+     */
+    abstract getCurrentPageId(): Observable<string | null>;
+}
+
+interface EditorElement {
+    id: string;
+    type: string;
+    props: Record<string, unknown>;
+    slotName?: string;
+    children?: EditorElement[];
+    adminLabel?: string;
+}
+interface EditorSection {
+    id: string;
+    type: string;
+    props: Record<string, unknown>;
+    elements: EditorElement[];
+    adminLabel?: string;
+}
+interface HistoryEntry {
+    sections: EditorSection[];
+    timestamp: number;
+    actionType: string;
+}
+interface VisualEditorState {
+    sections: EditorSection[];
+    selectedElementId: string | null;
+    selectedSectionId: string | null;
+    isDragging: boolean;
+    draggedElementId: string | null;
+    history: HistoryEntry[];
+    historyIndex: number;
+    maxHistorySize: number;
+    currentPage: PageContext | null;
+    isDirty: boolean;
+}
+declare const initialVisualEditorState: VisualEditorState;
+declare const VISUAL_EDITOR_FEATURE_KEY = "visualEditor";
+
+declare const SHOPIFY_API_VERSION = "2026-01";
+interface ShopifyConfig {
+    shopDomain: string;
+    accessToken: string;
+    apiVersion: string;
+}
+declare const SHOPIFY_CONFIG: InjectionToken<ShopifyConfig | Observable<ShopifyConfig>>;
+/**
+ * Metafield representation from Shopify
+ */
+interface Metafield {
+    id: string;
+    namespace: string;
+    key: string;
+    value: string;
+    type: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/**
+ * Page status - draft pages are only visible in admin, published pages are public
+ */
+type PageStatus = 'draft' | 'published';
+/**
+ * Entry in the pages index (lightweight reference)
+ */
+interface PageIndexEntry {
+    id: string;
+    slug: string;
+    title: string;
+    status: PageStatus;
+    updatedAt: string;
+    publishedAt?: string;
+    size: number;
+}
+/**
+ * Index of all pages stored in a single metafield
+ */
+interface PagesIndex {
+    version: number;
+    lastUpdated: string;
+    pages: PageIndexEntry[];
+}
+/**
+ * Full page model with all content
+ */
+interface Page {
+    id: string;
+    slug: string;
+    title: string;
+    description?: string;
+    sections: EditorSection[];
+    status: PageStatus;
+    createdAt: string;
+    updatedAt: string;
+    publishedAt?: string;
+    version: number;
+}
+/**
+ * Lightweight page summary for listing
+ */
+interface PageSummary {
+    id: string;
+    slug: string;
+    title: string;
+    status: PageStatus;
+    updatedAt: string;
+    publishedAt?: string;
+}
+/**
+ * Page context stored in editor state (minimal info needed while editing)
+ */
+interface PageContext {
+    id: string;
+    slug: string;
+    title: string;
+    status: PageStatus;
+    version: number;
+}
+/**
+ * Request payload for creating a new page
+ */
+interface CreatePageRequest {
+    title: string;
+    slug: string;
+    description?: string;
+}
+/**
+ * Request payload for updating an existing page
+ */
+interface UpdatePageRequest {
+    title?: string;
+    slug?: string;
+    description?: string;
+    sections?: EditorSection[];
+    version: number;
+}
+/**
+ * Request payload for publishing/unpublishing
+ */
+interface PublishPageRequest {
+    version: number;
+}
+
+/**
+ * Abstract strategy for loading pages into the editor
+ * Consumers can implement custom strategies for different use cases
+ */
+declare abstract class PageLoadingStrategy {
+    /**
+     * Load a page by ID
+     */
+    abstract loadPage(pageId: string): Observable<Page>;
+    /**
+     * Get the current page ID to load
+     * This abstracts the source of the page ID (route, input, etc.)
+     */
+    abstract getPageIdToLoad(): Observable<string | null>;
+}
+/**
+ * Default strategy that uses route params via the navigation service
+ */
+declare class RoutePageLoadingStrategy extends PageLoadingStrategy {
+    private readonly pageService;
+    private readonly navigation;
+    loadPage(pageId: string): Observable<Page>;
+    getPageIdToLoad(): Observable<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RoutePageLoadingStrategy, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RoutePageLoadingStrategy>;
+}
+/**
+ * Input-based strategy for when page is passed via component input
+ * Useful for embedding the editor in modals or custom layouts
+ */
+declare class InputPageLoadingStrategy extends PageLoadingStrategy {
+    private readonly pageService;
+    private readonly pageId$;
+    /**
+     * Set the page ID to load
+     * Call this when the input changes
+     */
+    setPageId(pageId: string | null): void;
+    loadPage(pageId: string): Observable<Page>;
+    getPageIdToLoad(): Observable<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputPageLoadingStrategy, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<InputPageLoadingStrategy>;
+}
+
+/**
+ * Configuration for the default router navigation
+ */
+interface RouterNavigationConfig {
+    /** Route path for page list (default: '/admin') */
+    pageListPath: string;
+    /** Route path pattern for page edit (default: '/admin/pages/:pageId') */
+    pageEditPath: string;
+    /** Route path pattern for preview (optional) */
+    pagePreviewPath?: string;
+    /** Route param name for page ID (default: 'pageId') */
+    pageIdParam: string;
+}
+/**
+ * Default router navigation configuration
+ */
+declare const DEFAULT_ROUTER_NAVIGATION_CONFIG: RouterNavigationConfig;
+/**
+ * Injection token for router navigation configuration
+ */
+declare const ROUTER_NAVIGATION_CONFIG: InjectionToken<RouterNavigationConfig>;
+/**
+ * Default navigation service implementation using Angular Router
+ */
+declare class DefaultRouterNavigationService extends VisualEditorNavigation {
+    private readonly router;
+    private readonly route;
+    private readonly config;
+    navigate(target: VisualEditorNavigationTarget): void;
+    confirm(options: ConfirmDialogOptions): Observable<boolean>;
+    getCurrentPageId(): Observable<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DefaultRouterNavigationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DefaultRouterNavigationService>;
+}
+
+/**
+ * Main configuration interface for the Visual Editor library
+ */
+interface VisualEditorConfig {
+    /**
+     * Navigation configuration
+     */
+    navigation?: {
+        /**
+         * Custom navigation service class
+         * If provided, routerConfig is ignored
+         */
+        navigationService?: Type<VisualEditorNavigation>;
+        /**
+         * Router-based config (used with DefaultRouterNavigationService)
+         * Only used if navigationService is not provided
+         */
+        routerConfig?: Partial<RouterNavigationConfig>;
+    };
+    /**
+     * Page loading configuration
+     */
+    pageLoading?: {
+        /**
+         * Custom page loading strategy
+         * Defaults to RoutePageLoadingStrategy
+         */
+        strategy?: Type<PageLoadingStrategy>;
+    };
+    /**
+     * Page service configuration
+     */
+    pages?: {
+        /**
+         * Use in-memory storage instead of Shopify
+         * Useful for development and demos
+         * Defaults to false (uses Shopify)
+         */
+        useInMemory?: boolean;
+    };
+    /**
+     * UI configuration
+     */
+    ui?: {
+        /**
+         * Show back button in editor toolbar
+         * Defaults to true
+         */
+        showBackButton?: boolean;
+        /**
+         * Show publish/unpublish buttons
+         * Defaults to true
+         */
+        showPublishButtons?: boolean;
+        /**
+         * Show save button
+         * Defaults to true
+         */
+        showSaveButton?: boolean;
+    };
+}
+/**
+ * Injection token for the Visual Editor configuration
+ */
+declare const VISUAL_EDITOR_CONFIG: InjectionToken<VisualEditorConfig>;
+/**
+ * Default configuration values
+ */
+declare const DEFAULT_VISUAL_EDITOR_CONFIG: Required<VisualEditorConfig>;
+
+/**
+ * Provides all necessary services and configuration for the Visual Editor
+ *
+ * Note: You must also call provideVisualEditorStore() to set up the NgRx state.
+ *
+ * @example
+ * ```typescript
+ * // Minimal setup (uses Shopify by default)
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideStore(),
+ *     provideVisualEditorStore(),  // Required: sets up NgRx state
+ *     provideVisualEditor(),        // Sets up services and config
+ *     provideEditorComponents(myComponents),
+ *   ],
+ * };
+ *
+ * // With custom configuration
+ * provideVisualEditor({
+ *   navigation: {
+ *     routerConfig: {
+ *       pageListPath: '/cms',
+ *       pageEditPath: '/cms/editor/:id',
+ *       pageIdParam: 'id',
+ *     }
+ *   },
+ *   pages: {
+ *     useInMemory: true  // Use in-memory storage for development
+ *   }
+ * })
+ * ```
+ */
+declare function provideVisualEditor(config?: VisualEditorConfig): EnvironmentProviders;
+
+declare const VisualEditorActions: {
+    addSection: _ngrx_store.ActionCreator<"[Visual Editor] Add Section", (props: {
+        section: EditorSection;
+        index?: number;
+    }) => {
+        section: EditorSection;
+        index?: number;
+    } & _ngrx_store.Action<"[Visual Editor] Add Section">>;
+    removeSection: _ngrx_store.ActionCreator<"[Visual Editor] Remove Section", (props: {
+        sectionId: string;
+    }) => {
+        sectionId: string;
+    } & _ngrx_store.Action<"[Visual Editor] Remove Section">>;
+    moveSection: _ngrx_store.ActionCreator<"[Visual Editor] Move Section", (props: {
+        sectionId: string;
+        newIndex: number;
+    }) => {
+        sectionId: string;
+        newIndex: number;
+    } & _ngrx_store.Action<"[Visual Editor] Move Section">>;
+    updateSection: _ngrx_store.ActionCreator<"[Visual Editor] Update Section", (props: {
+        sectionId: string;
+        changes: Partial<EditorSection>;
+    }) => {
+        sectionId: string;
+        changes: Partial<EditorSection>;
+    } & _ngrx_store.Action<"[Visual Editor] Update Section">>;
+    updateSectionProps: _ngrx_store.ActionCreator<"[Visual Editor] Update Section Props", (props: {
+        sectionId: string;
+        props: Record<string, unknown>;
+    }) => {
+        sectionId: string;
+        props: Record<string, unknown>;
+    } & _ngrx_store.Action<"[Visual Editor] Update Section Props">>;
+    addElement: _ngrx_store.ActionCreator<"[Visual Editor] Add Element", (props: {
+        sectionId: string;
+        element: EditorElement;
+        index?: number;
+    }) => {
+        sectionId: string;
+        element: EditorElement;
+        index?: number;
+    } & _ngrx_store.Action<"[Visual Editor] Add Element">>;
+    removeElement: _ngrx_store.ActionCreator<"[Visual Editor] Remove Element", (props: {
+        sectionId: string;
+        elementId: string;
+    }) => {
+        sectionId: string;
+        elementId: string;
+    } & _ngrx_store.Action<"[Visual Editor] Remove Element">>;
+    moveElement: _ngrx_store.ActionCreator<"[Visual Editor] Move Element", (props: {
+        sourceSectionId: string;
+        targetSectionId: string;
+        elementId: string;
+        newIndex: number;
+    }) => {
+        sourceSectionId: string;
+        targetSectionId: string;
+        elementId: string;
+        newIndex: number;
+    } & _ngrx_store.Action<"[Visual Editor] Move Element">>;
+    updateElement: _ngrx_store.ActionCreator<"[Visual Editor] Update Element", (props: {
+        sectionId: string;
+        elementId: string;
+        changes: Partial<EditorElement>;
+    }) => {
+        sectionId: string;
+        elementId: string;
+        changes: Partial<EditorElement>;
+    } & _ngrx_store.Action<"[Visual Editor] Update Element">>;
+    updateElementProps: _ngrx_store.ActionCreator<"[Visual Editor] Update Element Props", (props: {
+        sectionId: string;
+        elementId: string;
+        props: Record<string, unknown>;
+    }) => {
+        sectionId: string;
+        elementId: string;
+        props: Record<string, unknown>;
+    } & _ngrx_store.Action<"[Visual Editor] Update Element Props">>;
+    addBlock: _ngrx_store.ActionCreator<"[Visual Editor] Add Block", (props: {
+        sectionId: string;
+        slotName: string;
+        element: EditorElement;
+        index?: number;
+    }) => {
+        sectionId: string;
+        slotName: string;
+        element: EditorElement;
+        index?: number;
+    } & _ngrx_store.Action<"[Visual Editor] Add Block">>;
+    removeBlock: _ngrx_store.ActionCreator<"[Visual Editor] Remove Block", (props: {
+        sectionId: string;
+        elementId: string;
+    }) => {
+        sectionId: string;
+        elementId: string;
+    } & _ngrx_store.Action<"[Visual Editor] Remove Block">>;
+    moveBlock: _ngrx_store.ActionCreator<"[Visual Editor] Move Block", (props: {
+        sectionId: string;
+        elementId: string;
+        targetSlotName: string;
+        newIndex: number;
+    }) => {
+        sectionId: string;
+        elementId: string;
+        targetSlotName: string;
+        newIndex: number;
+    } & _ngrx_store.Action<"[Visual Editor] Move Block">>;
+    updateBlockProps: _ngrx_store.ActionCreator<"[Visual Editor] Update Block Props", (props: {
+        sectionId: string;
+        elementId: string;
+        props: Record<string, unknown>;
+    }) => {
+        sectionId: string;
+        elementId: string;
+        props: Record<string, unknown>;
+    } & _ngrx_store.Action<"[Visual Editor] Update Block Props">>;
+    renameSection: _ngrx_store.ActionCreator<"[Visual Editor] Rename Section", (props: {
+        sectionId: string;
+        adminLabel: string;
+    }) => {
+        sectionId: string;
+        adminLabel: string;
+    } & _ngrx_store.Action<"[Visual Editor] Rename Section">>;
+    renameBlock: _ngrx_store.ActionCreator<"[Visual Editor] Rename Block", (props: {
+        sectionId: string;
+        elementId: string;
+        adminLabel: string;
+    }) => {
+        sectionId: string;
+        elementId: string;
+        adminLabel: string;
+    } & _ngrx_store.Action<"[Visual Editor] Rename Block">>;
+    duplicateSection: _ngrx_store.ActionCreator<"[Visual Editor] Duplicate Section", (props: {
+        sectionId: string;
+    }) => {
+        sectionId: string;
+    } & _ngrx_store.Action<"[Visual Editor] Duplicate Section">>;
+    duplicateBlock: _ngrx_store.ActionCreator<"[Visual Editor] Duplicate Block", (props: {
+        sectionId: string;
+        elementId: string;
+    }) => {
+        sectionId: string;
+        elementId: string;
+    } & _ngrx_store.Action<"[Visual Editor] Duplicate Block">>;
+    duplicateNestedBlock: _ngrx_store.ActionCreator<"[Visual Editor] Duplicate Nested Block", (props: {
+        sectionId: string;
+        parentPath: string[];
+        elementId: string;
+    }) => {
+        sectionId: string;
+        parentPath: string[];
+        elementId: string;
+    } & _ngrx_store.Action<"[Visual Editor] Duplicate Nested Block">>;
+    addNestedBlock: _ngrx_store.ActionCreator<"[Visual Editor] Add Nested Block", (props: {
+        sectionId: string;
+        parentPath: string[];
+        slotName: string;
+        element: EditorElement;
+        index?: number;
+    }) => {
+        sectionId: string;
+        parentPath: string[];
+        slotName: string;
+        element: EditorElement;
+        index?: number;
+    } & _ngrx_store.Action<"[Visual Editor] Add Nested Block">>;
+    removeNestedBlock: _ngrx_store.ActionCreator<"[Visual Editor] Remove Nested Block", (props: {
+        sectionId: string;
+        parentPath: string[];
+        elementId: string;
+    }) => {
+        sectionId: string;
+        parentPath: string[];
+        elementId: string;
+    } & _ngrx_store.Action<"[Visual Editor] Remove Nested Block">>;
+    updateNestedBlockProps: _ngrx_store.ActionCreator<"[Visual Editor] Update Nested Block Props", (props: {
+        sectionId: string;
+        parentPath: string[];
+        elementId: string;
+        props: Record<string, unknown>;
+    }) => {
+        sectionId: string;
+        parentPath: string[];
+        elementId: string;
+        props: Record<string, unknown>;
+    } & _ngrx_store.Action<"[Visual Editor] Update Nested Block Props">>;
+    moveNestedBlock: _ngrx_store.ActionCreator<"[Visual Editor] Move Nested Block", (props: {
+        sectionId: string;
+        parentPath: string[];
+        elementId: string;
+        targetSlotName: string;
+        newIndex: number;
+    }) => {
+        sectionId: string;
+        parentPath: string[];
+        elementId: string;
+        targetSlotName: string;
+        newIndex: number;
+    } & _ngrx_store.Action<"[Visual Editor] Move Nested Block">>;
+    reparentBlock: _ngrx_store.ActionCreator<"[Visual Editor] Reparent Block", (props: {
+        sourceSectionId: string;
+        sourceParentPath: string[];
+        elementId: string;
+        targetSectionId: string;
+        targetParentPath: string[];
+        targetSlotName: string;
+        targetIndex: number;
+    }) => {
+        sourceSectionId: string;
+        sourceParentPath: string[];
+        elementId: string;
+        targetSectionId: string;
+        targetParentPath: string[];
+        targetSlotName: string;
+        targetIndex: number;
+    } & _ngrx_store.Action<"[Visual Editor] Reparent Block">>;
+    selectElement: _ngrx_store.ActionCreator<"[Visual Editor] Select Element", (props: {
+        sectionId: string | null;
+        elementId: string | null;
+    }) => {
+        sectionId: string | null;
+        elementId: string | null;
+    } & _ngrx_store.Action<"[Visual Editor] Select Element">>;
+    clearSelection: _ngrx_store.ActionCreator<"[Visual Editor] Clear Selection", () => _ngrx_store.Action<"[Visual Editor] Clear Selection">>;
+    startDrag: _ngrx_store.ActionCreator<"[Visual Editor] Start Drag", (props: {
+        elementId: string;
+    }) => {
+        elementId: string;
+    } & _ngrx_store.Action<"[Visual Editor] Start Drag">>;
+    endDrag: _ngrx_store.ActionCreator<"[Visual Editor] End Drag", () => _ngrx_store.Action<"[Visual Editor] End Drag">>;
+    undo: _ngrx_store.ActionCreator<"[Visual Editor] Undo", () => _ngrx_store.Action<"[Visual Editor] Undo">>;
+    redo: _ngrx_store.ActionCreator<"[Visual Editor] Redo", () => _ngrx_store.Action<"[Visual Editor] Redo">>;
+    clearHistory: _ngrx_store.ActionCreator<"[Visual Editor] Clear History", () => _ngrx_store.Action<"[Visual Editor] Clear History">>;
+    loadSections: _ngrx_store.ActionCreator<"[Visual Editor] Load Sections", (props: {
+        sections: EditorSection[];
+    }) => {
+        sections: EditorSection[];
+    } & _ngrx_store.Action<"[Visual Editor] Load Sections">>;
+    resetEditor: _ngrx_store.ActionCreator<"[Visual Editor] Reset Editor", () => _ngrx_store.Action<"[Visual Editor] Reset Editor">>;
+    loadPage: _ngrx_store.ActionCreator<"[Visual Editor] Load Page", (props: {
+        page: Page;
+    }) => {
+        page: Page;
+    } & _ngrx_store.Action<"[Visual Editor] Load Page">>;
+    updatePageContext: _ngrx_store.ActionCreator<"[Visual Editor] Update Page Context", (props: {
+        context: Partial<PageContext>;
+    }) => {
+        context: Partial<PageContext>;
+    } & _ngrx_store.Action<"[Visual Editor] Update Page Context">>;
+    markDirty: _ngrx_store.ActionCreator<"[Visual Editor] Mark Dirty", () => _ngrx_store.Action<"[Visual Editor] Mark Dirty">>;
+    markClean: _ngrx_store.ActionCreator<"[Visual Editor] Mark Clean", () => _ngrx_store.Action<"[Visual Editor] Mark Clean">>;
+    clearPage: _ngrx_store.ActionCreator<"[Visual Editor] Clear Page", () => _ngrx_store.Action<"[Visual Editor] Clear Page">>;
+};
+
+declare const visualEditorReducer: _ngrx_store.ActionReducer<VisualEditorState, _ngrx_store.Action<string>>;
+
+declare const selectVisualEditorState: _ngrx_store.MemoizedSelector<object, VisualEditorState, _ngrx_store.DefaultProjectorFn<VisualEditorState>>;
+declare const selectSections: _ngrx_store.MemoizedSelector<object, _kustomizer_visual_editor.EditorSection[], (s1: VisualEditorState) => _kustomizer_visual_editor.EditorSection[]>;
+declare const selectSelectedElementId: _ngrx_store.MemoizedSelector<object, string | null, (s1: VisualEditorState) => string | null>;
+declare const selectSelectedSectionId: _ngrx_store.MemoizedSelector<object, string | null, (s1: VisualEditorState) => string | null>;
+declare const selectIsDragging: _ngrx_store.MemoizedSelector<object, boolean, (s1: VisualEditorState) => boolean>;
+declare const selectDraggedElementId: _ngrx_store.MemoizedSelector<object, string | null, (s1: VisualEditorState) => string | null>;
+declare const selectHistoryIndex: _ngrx_store.MemoizedSelector<object, number, (s1: VisualEditorState) => number>;
+declare const selectHistoryLength: _ngrx_store.MemoizedSelector<object, number, (s1: VisualEditorState) => number>;
+declare const selectCanUndo: _ngrx_store.MemoizedSelector<object, boolean, (s1: VisualEditorState) => boolean>;
+declare const selectCanRedo: _ngrx_store.MemoizedSelector<object, boolean, (s1: VisualEditorState) => boolean>;
+declare const selectSelectedSection: _ngrx_store.MemoizedSelector<object, _kustomizer_visual_editor.EditorSection | null, (s1: _kustomizer_visual_editor.EditorSection[], s2: string | null) => _kustomizer_visual_editor.EditorSection | null>;
+declare const selectSelectedElement: _ngrx_store.MemoizedSelector<object, EditorElement | null, (s1: _kustomizer_visual_editor.EditorSection | null, s2: string | null) => EditorElement | null>;
+declare const selectSectionById: (sectionId: string) => _ngrx_store.MemoizedSelector<object, _kustomizer_visual_editor.EditorSection | null, (s1: _kustomizer_visual_editor.EditorSection[]) => _kustomizer_visual_editor.EditorSection | null>;
+declare const selectElementById: (sectionId: string, elementId: string) => _ngrx_store.MemoizedSelector<object, EditorElement | null, (s1: _kustomizer_visual_editor.EditorSection | null) => EditorElement | null>;
+declare const selectHistory: _ngrx_store.MemoizedSelector<object, _kustomizer_visual_editor.HistoryEntry[], (s1: VisualEditorState) => _kustomizer_visual_editor.HistoryEntry[]>;
+declare const selectLastAction: _ngrx_store.MemoizedSelector<object, string | null, (s1: _kustomizer_visual_editor.HistoryEntry[], s2: number) => string | null>;
+declare const selectSelectedElementType: _ngrx_store.MemoizedSelector<object, string | null, (s1: EditorElement | null) => string | null>;
+declare const selectSelectedSectionType: _ngrx_store.MemoizedSelector<object, string | null, (s1: _kustomizer_visual_editor.EditorSection | null) => string | null>;
+declare const selectBlocksForSection: (sectionId: string) => _ngrx_store.MemoizedSelector<object, EditorElement[], (s1: _kustomizer_visual_editor.EditorSection | null) => EditorElement[]>;
+declare const selectBlocksForSlot: (sectionId: string, slotName: string) => _ngrx_store.MemoizedSelector<object, EditorElement[], (s1: EditorElement[]) => EditorElement[]>;
+declare const selectSelectedBlock: _ngrx_store.MemoizedSelector<object, EditorElement | null, (s1: _kustomizer_visual_editor.EditorSection | null, s2: string | null) => EditorElement | null>;
+declare const selectSelectedBlockSlotName: _ngrx_store.MemoizedSelector<object, string | null, (s1: EditorElement | null) => string | null>;
+declare const selectCurrentPage: _ngrx_store.MemoizedSelector<object, _kustomizer_visual_editor.PageContext | null, (s1: VisualEditorState) => _kustomizer_visual_editor.PageContext | null>;
+declare const selectCurrentPageId: _ngrx_store.MemoizedSelector<object, string | null, (s1: _kustomizer_visual_editor.PageContext | null) => string | null>;
+declare const selectCurrentPageSlug: _ngrx_store.MemoizedSelector<object, string | null, (s1: _kustomizer_visual_editor.PageContext | null) => string | null>;
+declare const selectCurrentPageTitle: _ngrx_store.MemoizedSelector<object, string | null, (s1: _kustomizer_visual_editor.PageContext | null) => string | null>;
+declare const selectCurrentPageStatus: _ngrx_store.MemoizedSelector<object, _kustomizer_visual_editor.PageStatus | null, (s1: _kustomizer_visual_editor.PageContext | null) => _kustomizer_visual_editor.PageStatus | null>;
+declare const selectCurrentPageVersion: _ngrx_store.MemoizedSelector<object, number | null, (s1: _kustomizer_visual_editor.PageContext | null) => number | null>;
+declare const selectIsDirty: _ngrx_store.MemoizedSelector<object, boolean, (s1: VisualEditorState) => boolean>;
+declare const selectIsPageLoaded: _ngrx_store.MemoizedSelector<object, boolean, (s1: _kustomizer_visual_editor.PageContext | null) => boolean>;
+
+declare function provideVisualEditorStore(): EnvironmentProviders;
+
+/**
+ * Supported property types for the editor
+ */
+type PropType = 'string' | 'number' | 'boolean' | 'color' | 'image' | 'video' | 'url' | 'richtext' | 'textarea' | 'select' | 'range' | 'json';
+/**
+ * Option for select-type properties
+ */
+interface SelectOption {
+    label: string;
+    value: string | number;
+}
+/**
+ * Validation rules for a property
+ */
+interface PropValidation {
+    required?: boolean;
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+}
+/**
+ * Condition to show/hide a property based on another property's value
+ */
+interface PropCondition {
+    dependsOn: string;
+    equals?: unknown;
+    oneOf?: unknown[];
+}
+/**
+ * Schema definition for a single property
+ */
+interface PropSchema<T = unknown> {
+    type: PropType;
+    label: string;
+    description?: string;
+    defaultValue: T;
+    placeholder?: string;
+    validation?: PropValidation;
+    condition?: PropCondition;
+    group?: string;
+    order?: number;
+    options?: SelectOption[];
+    step?: number;
+    accept?: string[];
+}
+/**
+ * Map of property names to their schemas
+ */
+type PropSchemaMap = Record<string, PropSchema>;
+
+/**
+ * Constraints for what can be placed in a slot
+ */
+interface SlotConstraints {
+    allowedTypes?: string[];
+    disallowedTypes?: string[];
+    minItems?: number;
+    maxItems?: number;
+}
+/**
+ * Definition of a slot where child components can be inserted
+ */
+interface SlotDefinition {
+    name: string;
+    label: string;
+    description?: string;
+    constraints?: SlotConstraints;
+    emptyPlaceholder?: string;
+    droppable?: boolean;
+}
+
+/**
+ * Category for grouping components in the editor panel
+ */
+type ComponentCategory = 'layout' | 'content' | 'media' | 'form' | 'navigation' | 'commerce' | 'custom';
+/**
+ * Block configuration within a preset
+ */
+interface PresetBlockConfig {
+    type: string;
+    settings?: Record<string, unknown>;
+    slotName?: string;
+    blocks?: PresetBlockConfig[];
+}
+/**
+ * Pre-configured variant of a component
+ */
+interface ComponentPreset {
+    name: string;
+    category?: string;
+    description?: string;
+    icon?: string;
+    thumbnail?: string;
+    settings?: Record<string, unknown>;
+    blocks?: PresetBlockConfig[];
+}
+/**
+ * Complete definition of a registered editor component
+ */
+interface ComponentDefinition<TProps extends Record<string, unknown> = Record<string, unknown>> {
+    /**
+     * Unique identifier matching EditorElement.type or EditorSection.type
+     */
+    type: string;
+    /**
+     * Display name in the component panel
+     */
+    name: string;
+    /**
+     * Description of the component
+     */
+    description?: string;
+    /**
+     * Category for grouping in the component panel
+     */
+    category: ComponentCategory;
+    /**
+     * Icon name or URL
+     */
+    icon?: string;
+    /**
+     * Angular component class to render
+     */
+    component: Type<unknown>;
+    /**
+     * Schema of editable properties
+     */
+    props: PropSchemaMap;
+    /**
+     * Available slots for child components
+     */
+    slots?: SlotDefinition[];
+    /**
+     * Whether this is a section (top-level container) vs element
+     */
+    isSection?: boolean;
+    /**
+     * Whether this is a block (element that lives inside section slots)
+     */
+    isBlock?: boolean;
+    /**
+     * Scope of the block: 'theme' = available in all sections, 'section' = only in specific sections
+     * Defaults to 'theme' if not specified
+     */
+    blockScope?: 'section' | 'theme';
+    /**
+     * Section types where this block is available (only used when blockScope is 'section')
+     */
+    sectionTypes?: string[];
+    /**
+     * Whether the component can be dragged/reordered
+     */
+    draggable?: boolean;
+    /**
+     * Whether the component can be deleted
+     */
+    deletable?: boolean;
+    /**
+     * Whether the component can be duplicated
+     */
+    duplicable?: boolean;
+    /**
+     * Thumbnail URL for the component panel
+     */
+    thumbnail?: string;
+    /**
+     * Tags for search
+     */
+    tags?: string[];
+    /**
+     * Order in the component list (lower = first)
+     */
+    order?: number;
+    /**
+     * Pre-configured presets for this component.
+     * Each preset appears as a separate entry in the picker.
+     */
+    presets?: ComponentPreset[];
+}
+
+/**
+ * A resolved preset entry for use in pickers.
+ * If the component has no presets, preset is null and display fields come from the definition.
+ */
+interface ResolvedPreset {
+    definition: ComponentDefinition;
+    preset: ComponentPreset | null;
+    displayName: string;
+    displayCategory: string;
+    displayIcon: string | undefined;
+    displayDescription: string | undefined;
+}
+/**
+ * Central service for registering and querying editor components
+ */
+declare class ComponentRegistryService {
+    private readonly definitions;
+    private readonly injectedDefinitions;
+    constructor();
+    /**
+     * Register a component definition
+     */
+    register(definition: ComponentDefinition): void;
+    /**
+     * Register multiple definitions
+     */
+    registerAll(definitions: ComponentDefinition[]): void;
+    /**
+     * Get a definition by type
+     */
+    get(type: string): ComponentDefinition | undefined;
+    /**
+     * Check if a type is registered
+     */
+    has(type: string): boolean;
+    /**
+     * Get the Angular component for a type
+     */
+    getComponent(type: string): Type<unknown> | undefined;
+    /**
+     * Get the props schema for a type
+     */
+    getPropsSchema(type: string): PropSchemaMap | undefined;
+    /**
+     * Get the slots for a type
+     */
+    getSlots(type: string): SlotDefinition[];
+    /**
+     * Check if a component type has slots (can contain nested blocks)
+     */
+    hasSlots(type: string): boolean;
+    /**
+     * Get all definitions
+     */
+    getAll(): ComponentDefinition[];
+    /**
+     * Get definitions filtered by category
+     */
+    getByCategory(category: ComponentCategory): ComponentDefinition[];
+    /**
+     * Get only section components
+     */
+    getSections(): ComponentDefinition[];
+    /**
+     * Get only element components (non-sections, non-blocks)
+     */
+    getElements(): ComponentDefinition[];
+    /**
+     * Get only block components (elements that live inside section slots)
+     */
+    getBlocks(): ComponentDefinition[];
+    /**
+     * Get blocks available for a specific section type
+     * Returns theme blocks (global) + section blocks specific to this section type
+     */
+    getBlocksForSectionType(sectionType: string): ComponentDefinition[];
+    /**
+     * Search components by name or tags
+     */
+    search(query: string): ComponentDefinition[];
+    /**
+     * Generate default props for a type
+     */
+    getDefaultProps(type: string): Record<string, unknown>;
+    /**
+     * Resolve a definition into ResolvedPreset entries.
+     * If it has presets, returns one entry per preset; otherwise one entry for the definition itself.
+     */
+    resolvePresets(definition: ComponentDefinition): ResolvedPreset[];
+    /**
+     * Get all section definitions expanded into presets
+     */
+    getSectionPresets(): ResolvedPreset[];
+    /**
+     * Get all block definitions expanded into presets
+     */
+    getBlockPresets(): ResolvedPreset[];
+    /**
+     * Get block presets available for a specific section type
+     */
+    getBlockPresetsForSectionType(sectionType: string): ResolvedPreset[];
+    /**
+     * Merge schema defaults with preset settings to produce final props
+     */
+    getPresetProps(type: string, preset: ComponentPreset | null): Record<string, unknown>;
+    /**
+     * Validate props against the schema
+     */
+    validateProps(type: string, props: Record<string, unknown>): Map<string, string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ComponentRegistryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ComponentRegistryService>;
+}
+
+/**
+ * Injection token for editor component definitions
+ */
+declare const EDITOR_COMPONENT_DEFINITIONS: InjectionToken<ComponentDefinition<Record<string, unknown>>[][]>;
+/**
+ * Provider function to register editor components.
+ *
+ * @example
+ * ```typescript
+ * // app.config.ts
+ * export const appConfig: ApplicationConfig = {
+ *   providers: [
+ *     provideStore(),
+ *     provideVisualEditorStore(),
+ *     provideEditorComponents([
+ *       heroSectionDefinition,
+ *       textBlockDefinition,
+ *     ]),
+ *   ],
+ * };
+ * ```
+ */
+declare function provideEditorComponents(definitions: ComponentDefinition[]): EnvironmentProviders;
+
+/**
+ * Component that dynamically renders an EditorElement
+ * based on its type registered in the ComponentRegistry
+ */
+declare class DynamicRendererComponent {
+    private readonly registry;
+    private readonly viewContainerRef;
+    private readonly destroyRef;
+    /** Element to render */
+    readonly element: _angular_core.InputSignal<EditorElement>;
+    /** Additional context (sectionId, index, etc.) */
+    readonly context: _angular_core.InputSignal<Record<string, unknown>>;
+    /** Error state signal */
+    private _error;
+    error: () => boolean;
+    private componentRef;
+    private currentType;
+    private currentAvailableInputs;
+    private previousInputs;
+    constructor();
+    private renderComponent;
+    private updateInputs;
+    private setInputIfChanged;
+    private getComponentInputs;
+    private cleanup;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicRendererComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicRendererComponent, "lib-dynamic-renderer", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Renders child elements within a specific slot
+ */
+declare class SlotRendererComponent {
+    private readonly registry;
+    /** Slot definition */
+    readonly slot: _angular_core.InputSignal<SlotDefinition>;
+    /** All children of the parent element */
+    readonly children: _angular_core.InputSignal<EditorElement[]>;
+    /** Parent element ID */
+    readonly parentElementId: _angular_core.InputSignal<string>;
+    /** Children filtered by slot name and constraints */
+    readonly filteredChildren: _angular_core.Signal<EditorElement[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlotRendererComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlotRendererComponent, "lib-slot-renderer", never, { "slot": { "alias": "slot"; "required": true; "isSignal": true; }; "children": { "alias": "children"; "required": true; "isSignal": true; }; "parentElementId": { "alias": "parentElementId"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Facade service that combines Store operations with ComponentRegistry
+ */
+declare class VisualEditorFacade {
+    private readonly store;
+    private readonly registry;
+    private readonly pageService;
+    readonly sections: _angular_core.Signal<EditorSection[]>;
+    readonly selectedElement: _angular_core.Signal<EditorElement | null>;
+    readonly selectedSection: _angular_core.Signal<EditorSection | null>;
+    readonly canUndo: _angular_core.Signal<boolean>;
+    readonly canRedo: _angular_core.Signal<boolean>;
+    readonly isDragging: _angular_core.Signal<boolean>;
+    readonly selectedBlock: _angular_core.Signal<EditorElement | null>;
+    readonly selectedBlockSlotName: _angular_core.Signal<string | null>;
+    readonly currentPage: _angular_core.Signal<PageContext | null>;
+    readonly currentPageId: _angular_core.Signal<string | null>;
+    readonly isDirty: _angular_core.Signal<boolean>;
+    readonly isPageLoaded: _angular_core.Signal<boolean>;
+    readonly selectedElementDefinition: _angular_core.Signal<ComponentDefinition<Record<string, unknown>> | null>;
+    readonly selectedSectionDefinition: _angular_core.Signal<ComponentDefinition<Record<string, unknown>> | null>;
+    readonly selectedBlockDefinition: _angular_core.Signal<ComponentDefinition<Record<string, unknown>> | null>;
+    readonly availableSections: _angular_core.Signal<ComponentDefinition<Record<string, unknown>>[]>;
+    readonly availableElements: _angular_core.Signal<ComponentDefinition<Record<string, unknown>>[]>;
+    readonly availableBlocks: _angular_core.Signal<ComponentDefinition<Record<string, unknown>>[]>;
+    readonly availableSectionPresets: _angular_core.Signal<ResolvedPreset[]>;
+    readonly availableBlockPresets: _angular_core.Signal<ResolvedPreset[]>;
+    /**
+     * Create a new element with default props from registry
+     */
+    createElementWithDefaults(type: string, overrides?: Partial<EditorElement>): EditorElement;
+    /**
+     * Create a new section with default props from registry
+     */
+    createSectionWithDefaults(type: string, overrides?: Partial<EditorSection>): EditorSection;
+    /**
+     * Add a section to the editor
+     */
+    addSection(type: string, index?: number): void;
+    /**
+     * Add an element to a section
+     */
+    addElement(sectionId: string, type: string, index?: number): void;
+    /**
+     * Remove a section
+     */
+    removeSection(sectionId: string): void;
+    /**
+     * Remove an element
+     */
+    removeElement(sectionId: string, elementId: string): void;
+    /**
+     * Move a section to a new index
+     */
+    moveSection(sectionId: string, newIndex: number): void;
+    /**
+     * Move an element within or between sections
+     */
+    moveElement(sourceSectionId: string, targetSectionId: string, elementId: string, newIndex: number): void;
+    /**
+     * Rename a section (set adminLabel)
+     */
+    renameSection(sectionId: string, adminLabel: string): void;
+    /**
+     * Rename a block (set adminLabel)
+     */
+    renameBlock(sectionId: string, elementId: string, adminLabel: string): void;
+    /**
+     * Create a block element with default props and slotName
+     */
+    createBlockWithDefaults(type: string, slotName: string, overrides?: Partial<EditorElement>): EditorElement;
+    /**
+     * Add a block to a section's slot
+     */
+    addBlock(sectionId: string, slotName: string, type: string, index?: number): void;
+    /**
+     * Add a section from a resolved preset.
+     * Merges preset settings into default props and creates pre-configured blocks.
+     */
+    addSectionFromPreset(resolvedPreset: ResolvedPreset, index?: number): void;
+    /**
+     * Add a block from a resolved preset to a section's slot.
+     */
+    addBlockFromPreset(sectionId: string, slotName: string, resolvedPreset: ResolvedPreset, index?: number): void;
+    /**
+     * Generate EditorElement[] from a preset's blocks configuration
+     */
+    private createPresetBlocks;
+    /**
+     * Generate children for blocks that have slots, from preset block configs
+     */
+    private createPresetBlockChildren;
+    /**
+     * Remove a block from a section
+     */
+    removeBlock(sectionId: string, elementId: string): void;
+    /**
+     * Move a block within a section (can change slots)
+     */
+    moveBlock(sectionId: string, elementId: string, targetSlotName: string, newIndex: number): void;
+    /**
+     * Check if a section type can be duplicated
+     */
+    isSectionDuplicable(type: string): boolean;
+    /**
+     * Check if a block type can be duplicated
+     */
+    isBlockDuplicable(type: string): boolean;
+    /**
+     * Duplicate a section (deep clone with new IDs)
+     */
+    duplicateSection(sectionId: string): void;
+    /**
+     * Duplicate a block within a section
+     */
+    duplicateBlock(sectionId: string, elementId: string): void;
+    /**
+     * Duplicate a nested block
+     */
+    duplicateNestedBlock(sectionId: string, parentPath: string[], elementId: string): void;
+    /**
+     * Update block props with validation (works for both direct and nested blocks)
+     */
+    updateBlockProps(sectionId: string, elementId: string, props: Record<string, unknown>): void;
+    /**
+     * Get blocks for a specific slot in a section
+     */
+    getBlocksForSlot(sectionId: string, slotName: string): EditorElement[];
+    /**
+     * Get allowed block types for a slot
+     */
+    getAllowedBlocksForSlot(sectionType: string, slotName: string): ComponentDefinition[];
+    /**
+     * Check if a component type has slots (can contain nested blocks)
+     */
+    hasSlots(type: string): boolean;
+    /**
+     * Get slots for a block type
+     */
+    getBlockSlots(type: string): SlotDefinition[];
+    /**
+     * Check if adding a nested block is allowed (max 12 levels)
+     */
+    canAddNestedBlock(parentPath: string[]): boolean;
+    /**
+     * Add a nested block to a parent element
+     */
+    addNestedBlock(sectionId: string, parentPath: string[], slotName: string, type: string, index?: number): void;
+    /**
+     * Remove a nested block from a parent element
+     */
+    removeNestedBlock(sectionId: string, parentPath: string[], elementId: string): void;
+    /**
+     * Update nested block props
+     */
+    updateNestedBlockProps(sectionId: string, parentPath: string[], elementId: string, props: Record<string, unknown>): void;
+    /**
+     * Move a nested block within its parent
+     */
+    moveNestedBlock(sectionId: string, parentPath: string[], elementId: string, targetSlotName: string, newIndex: number): void;
+    /**
+     * Reparent a block: move it from one parent/section to another
+     */
+    reparentBlock(sourceSectionId: string, sourceParentPath: string[], elementId: string, targetSectionId: string, targetParentPath: string[], targetSlotName: string, targetIndex: number): void;
+    /**
+     * Get children of an element filtered by slot
+     */
+    getElementChildren(element: EditorElement, slotName?: string): EditorElement[];
+    /**
+     * Get allowed blocks for a nested slot
+     */
+    getAllowedBlocksForNestedSlot(parentType: string, slotName: string): ComponentDefinition[];
+    /**
+     * Select an element
+     */
+    selectElement(sectionId: string | null, elementId: string | null): void;
+    /**
+     * Clear selection
+     */
+    clearSelection(): void;
+    /**
+     * Update element props with validation
+     */
+    updateElementProps(sectionId: string, elementId: string, props: Record<string, unknown>): void;
+    /**
+     * Update section props with validation
+     */
+    updateSectionProps(sectionId: string, props: Record<string, unknown>): void;
+    /**
+     * Undo last action
+     */
+    undo(): void;
+    /**
+     * Redo last undone action
+     */
+    redo(): void;
+    /**
+     * Load sections into the editor
+     */
+    loadSections(sections: EditorSection[]): void;
+    /**
+     * Reset editor to initial state
+     */
+    resetEditor(): void;
+    /**
+     * Get component definition by type
+     */
+    getDefinition(type: string): ComponentDefinition | undefined;
+    /**
+     * Search components
+     */
+    searchComponents(query: string): ComponentDefinition[];
+    /**
+     * Get all pages (summaries)
+     */
+    getPages(): Observable<PageSummary[]>;
+    /**
+     * Get a page by ID and load it into the editor
+     */
+    getPage(id: string): Observable<Page>;
+    /**
+     * Get a published page by slug (for public rendering)
+     */
+    getPublishedPageBySlug(slug: string): Observable<Page>;
+    /**
+     * Load a page into the editor
+     */
+    loadPage(page: Page): void;
+    /**
+     * Create a new page
+     */
+    createPage(request: CreatePageRequest): Observable<Page>;
+    /**
+     * Save current editor state to a page
+     */
+    savePage(pageId: string): Observable<Page>;
+    /**
+     * Update page metadata (title, slug, etc.)
+     */
+    updatePageMetadata(pageId: string, metadata: Partial<PageContext>): Observable<Page>;
+    /**
+     * Delete a page
+     */
+    deletePage(id: string): Observable<void>;
+    /**
+     * Publish a page
+     */
+    publishPage(pageId: string): Observable<Page>;
+    /**
+     * Unpublish a page
+     */
+    unpublishPage(pageId: string): Observable<Page>;
+    /**
+     * Duplicate a page
+     */
+    duplicatePage(id: string): Observable<Page>;
+    /**
+     * Clear the current page from editor
+     */
+    clearPage(): void;
+    /**
+     * Mark editor as dirty (has unsaved changes)
+     */
+    markDirty(): void;
+    /**
+     * Mark editor as clean (no unsaved changes)
+     */
+    markClean(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VisualEditorFacade, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<VisualEditorFacade>;
+}
+
+type DropZone = 'before' | 'inside' | 'after';
+type DragItemKind = 'section' | 'block';
+interface DragItem {
+    kind: DragItemKind;
+    elementId: string;
+    elementType: string;
+    sectionId: string;
+    parentPath: string[];
+    slotName?: string;
+    sourceIndex: number;
+}
+interface DropTarget {
+    kind: DragItemKind;
+    sectionId: string;
+    parentPath: string[];
+    slotName: string;
+    index: number;
+    depth: number;
+    zone: DropZone;
+}
+
+/**
+ * Context for a block in the tree hierarchy
+ */
+interface BlockTreeContext {
+    sectionId: string;
+    parentPath: string[];
+    depth: number;
+}
+/**
+ * Target information for opening the block picker
+ */
+interface BlockPickerTarget {
+    sectionId: string;
+    parentPath: string[];
+    parentType: string;
+    slots: SlotDefinition[];
+}
+/**
+ * Recursive component for rendering a block in the sidebar tree
+ * Supports nested blocks with expand/collapse functionality
+ */
+declare class BlockTreeItemComponent {
+    readonly facade: VisualEditorFacade;
+    private readonly dndService;
+    private readonly sanitizer;
+    private readonly treeBlock;
+    readonly block: _angular_core.InputSignal<EditorElement>;
+    readonly context: _angular_core.InputSignal<BlockTreeContext>;
+    readonly index: _angular_core.InputSignal<number>;
+    readonly totalSiblings: _angular_core.InputSignal<number>;
+    readonly expandAll: _angular_core.InputSignal<boolean>;
+    readonly selectBlock: _angular_core.OutputEmitterRef<{
+        block: EditorElement;
+        context: BlockTreeContext;
+    }>;
+    readonly deleteBlock: _angular_core.OutputEmitterRef<{
+        block: EditorElement;
+        context: BlockTreeContext;
+    }>;
+    readonly duplicateBlock: _angular_core.OutputEmitterRef<{
+        block: EditorElement;
+        context: BlockTreeContext;
+    }>;
+    readonly moveBlock: _angular_core.OutputEmitterRef<{
+        block: EditorElement;
+        context: BlockTreeContext;
+        newIndex: number;
+    }>;
+    readonly openBlockPicker: _angular_core.OutputEmitterRef<BlockPickerTarget>;
+    private readonly expanded;
+    readonly dropZone: _angular_core.WritableSignal<DropZone | null>;
+    readonly isDragSource: _angular_core.Signal<boolean>;
+    readonly blockHasSlots: _angular_core.Signal<boolean>;
+    readonly blockSlots: _angular_core.Signal<SlotDefinition[]>;
+    readonly children: _angular_core.Signal<EditorElement[]>;
+    readonly childContext: _angular_core.Signal<BlockTreeContext>;
+    readonly blockIcon: _angular_core.Signal<SafeHtml>;
+    readonly blockName: _angular_core.Signal<string>;
+    readonly duplicable: _angular_core.Signal<boolean>;
+    readonly canAddMore: _angular_core.Signal<boolean>;
+    isExpanded(): boolean;
+    toggleExpand(event: Event): void;
+    hasSlots(): boolean;
+    getBlockSlots(): SlotDefinition[];
+    onDuplicate(event: Event): void;
+    onSelect(event: Event): void;
+    onDelete(event: Event): void;
+    onMoveUp(event: Event): void;
+    onMoveDown(event: Event): void;
+    onAddBlock(event: Event): void;
+    onDragStart(event: DragEvent): void;
+    onDragEnd(event: DragEvent): void;
+    onDragOver(event: DragEvent): void;
+    onDragLeave(event: DragEvent): void;
+    onDrop(event: DragEvent): void;
+    onDragHandleKeydown(event: KeyboardEvent): void;
+    private buildDropTarget;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlockTreeItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BlockTreeItemComponent, "lib-block-tree-item", never, { "block": { "alias": "block"; "required": true; "isSignal": true; }; "context": { "alias": "context"; "required": true; "isSignal": true; }; "index": { "alias": "index"; "required": true; "isSignal": true; }; "totalSiblings": { "alias": "totalSiblings"; "required": true; "isSignal": true; }; "expandAll": { "alias": "expandAll"; "required": false; "isSignal": true; }; }, { "selectBlock": "selectBlock"; "deleteBlock": "deleteBlock"; "duplicateBlock": "duplicateBlock"; "moveBlock": "moveBlock"; "openBlockPicker": "openBlockPicker"; }, never, never, true, never>;
+}
+
+/**
+ * Main Visual Editor component
+ * Provides a complete editing interface with:
+ * - Sidebar with hierarchical tree view
+ * - Canvas with live preview
+ * - Properties panel for editing section/block properties
+ */
+declare class VisualEditorComponent implements OnInit, OnDestroy {
+    readonly facade: VisualEditorFacade;
+    private readonly registry;
+    private readonly navigation;
+    private readonly loadingStrategy;
+    private readonly config;
+    private readonly dndService;
+    private readonly sanitizer;
+    private readonly destroy$;
+    readonly showBackButton: _angular_core.Signal<boolean>;
+    readonly showPublishButtons: _angular_core.Signal<boolean>;
+    readonly showSaveButton: _angular_core.Signal<boolean>;
+    readonly isPreviewMode: _angular_core.WritableSignal<boolean>;
+    readonly editorContext: _angular_core.Signal<{
+        isEditor: boolean;
+    }>;
+    private readonly canvasEl;
+    readonly propertiesTab: _angular_core.WritableSignal<"props" | "blocks">;
+    readonly expandedGroups: _angular_core.WritableSignal<Set<string>>;
+    readonly expandedSections: _angular_core.WritableSignal<Set<string>>;
+    readonly allBlocksExpanded: _angular_core.WritableSignal<Set<string>>;
+    readonly showSectionPicker: _angular_core.WritableSignal<boolean>;
+    readonly blockPickerSection: _angular_core.WritableSignal<EditorSection | null>;
+    readonly nestedBlockPickerTarget: _angular_core.WritableSignal<BlockPickerTarget | null>;
+    readonly filePickerOpen: _angular_core.WritableSignal<boolean>;
+    readonly filePickerMediaType: _angular_core.WritableSignal<"IMAGE" | "VIDEO">;
+    readonly filePickerTargetKey: _angular_core.WritableSignal<string>;
+    readonly filePickerContext: _angular_core.WritableSignal<"section" | "block">;
+    readonly filePickerCurrentValue: _angular_core.Signal<string>;
+    readonly isSaving: _angular_core.WritableSignal<boolean>;
+    readonly isPublishing: _angular_core.WritableSignal<boolean>;
+    readonly isLoading: _angular_core.WritableSignal<boolean>;
+    readonly searchQuery: _angular_core.WritableSignal<string>;
+    readonly sectionPickerSearch: _angular_core.WritableSignal<string>;
+    readonly blockPickerSearch: _angular_core.WritableSignal<string>;
+    readonly nestedBlockPickerSearch: _angular_core.WritableSignal<string>;
+    readonly sectionDropZone: _angular_core.WritableSignal<string | null>;
+    readonly dndAnnouncement: _angular_core.WritableSignal<string>;
+    private sectionAutoExpandTimer;
+    readonly filteredSections: _angular_core.Signal<EditorSection[]>;
+    readonly filteredAvailableSectionPresets: _angular_core.Signal<ResolvedPreset[]>;
+    readonly groupedSectionPresets: _angular_core.Signal<{
+        category: string;
+        presets: ResolvedPreset[];
+    }[]>;
+    readonly filteredBlockPresetsForSection: _angular_core.Signal<ResolvedPreset[]>;
+    readonly filteredBlockPresetsForNestedSlot: _angular_core.Signal<ResolvedPreset[]>;
+    private readonly sectionIconMap;
+    private readonly blockIconMap;
+    readonly selectedBlockDefinition: _angular_core.Signal<ComponentDefinition<Record<string, unknown>> | null>;
+    private readonly nameInput;
+    readonly isEditingName: _angular_core.WritableSignal<boolean>;
+    readonly editingNameValue: _angular_core.WritableSignal<string>;
+    getSelectedDisplayName(def: ComponentDefinition): string;
+    getSelectedDefaultName(def: ComponentDefinition): string;
+    startEditingName(): void;
+    saveEditingName(event: Event): void;
+    cancelEditingName(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    goBack(): void;
+    savePage(): void;
+    publishPage(): void;
+    unpublishPage(): void;
+    private readonly defaultSectionIcon;
+    private readonly defaultBlockIcon;
+    private toSafeIcon;
+    getIcon(def: ComponentDefinition): SafeHtml;
+    getBlockIcon(def: ComponentDefinition): SafeHtml;
+    getBlockIconByType(type: string): SafeHtml;
+    getSectionIcon(type: string): SafeHtml;
+    isSectionExpanded(sectionId: string): boolean;
+    isAllBlocksExpanded(sectionId: string): boolean;
+    toggleSectionExpand(sectionId: string, event: Event): void;
+    toggleGroup(entityId: string, group: string): void;
+    isGroupCollapsed(entityId: string, group: string): boolean;
+    getSectionBlocks(section: EditorSection): EditorElement[];
+    private readonly rootBlockContextCache;
+    private readonly emptyPath;
+    getRootBlockContext(sectionId: string): BlockTreeContext;
+    onSearchInput(event: Event): void;
+    clearSearch(): void;
+    isSectionDragSource(sectionId: string): boolean;
+    onSectionDragStart(section: EditorSection, index: number, event: DragEvent): void;
+    onSectionDragEnd(event: DragEvent): void;
+    onSectionDragOver(section: EditorSection, index: number, event: DragEvent): void;
+    onSectionDragLeave(event: DragEvent): void;
+    onSectionDrop(event: DragEvent): void;
+    onSectionDragHandleKeydown(sectionId: string, index: number, event: KeyboardEvent): void;
+    onSectionContentDragOver(section: EditorSection, event: DragEvent): void;
+    onSectionContentDragLeave(event: DragEvent): void;
+    onSectionContentDrop(event: DragEvent): void;
+    private startAutoExpandTimer;
+    private clearAutoExpandTimer;
+    private scrollToCanvasElement;
+    /** Return the element itself if it has a box, otherwise its first laid-out child. */
+    private resolveScrollTarget;
+    private scrollToCanvasSection;
+    onSectionPickerSearch(event: Event): void;
+    onBlockPickerSearch(event: Event): void;
+    toggleSectionPicker(): void;
+    openBlockPicker(section: EditorSection, event: Event): void;
+    closeBlockPicker(): void;
+    onOpenNestedBlockPicker(target: BlockPickerTarget): void;
+    closeNestedBlockPicker(): void;
+    onNestedBlockPickerSearch(event: Event): void;
+    addNestedBlock(blockType: string): void;
+    onBlockSelect(event: {
+        block: EditorElement;
+        context: BlockTreeContext;
+    }): void;
+    onBlockDelete(event: {
+        block: EditorElement;
+        context: BlockTreeContext;
+    }): void;
+    onBlockMove(event: {
+        block: EditorElement;
+        context: BlockTreeContext;
+        newIndex: number;
+    }): void;
+    onBlockDuplicate(event: {
+        block: EditorElement;
+        context: BlockTreeContext;
+    }): void;
+    duplicateSection(sectionId: string, event: Event): void;
+    duplicateBlock(block: EditorElement, event: Event): void;
+    addBlockToSection(section: EditorSection, blockType: string): void;
+    getSectionName(section: EditorSection): string;
+    getBlockName(block: EditorElement): string;
+    addSection(type: string): void;
+    addSectionFromPreset(rp: ResolvedPreset): void;
+    addBlockToSectionFromPreset(section: EditorSection, rp: ResolvedPreset): void;
+    addNestedBlockFromPreset(rp: ResolvedPreset): void;
+    getSectionPresetIcon(rp: ResolvedPreset): SafeHtml;
+    getBlockPresetIcon(rp: ResolvedPreset): SafeHtml;
+    selectSection(section: EditorSection, event: Event): void;
+    selectBlock(block: EditorElement): void;
+    deleteSection(sectionId: string, event: Event): void;
+    deleteBlock(block: EditorElement, event: Event): void;
+    deleteSelectedBlock(): void;
+    moveUp(sectionId: string, currentIndex: number, event: Event): void;
+    moveDown(sectionId: string, currentIndex: number, event: Event): void;
+    moveBlockUp(block: EditorElement, slotName: string, currentIndex: number, event: Event): void;
+    moveBlockDown(block: EditorElement, slotName: string, currentIndex: number, event: Event): void;
+    togglePreview(): void;
+    getSectionSlots(): SlotDefinition[];
+    getBlocksForSlot(slotName: string): EditorElement[];
+    getBlockCount(): number;
+    getPropertyGroups(def: ComponentDefinition): string[];
+    getPropsForGroup(def: ComponentDefinition, group: string): Array<{
+        key: string;
+        schema: (typeof def.props)[string];
+    }>;
+    getPropertyValue(key: string): string;
+    updateProperty(key: string, event: Event): void;
+    getBlockPropertyGroups(): string[];
+    getBlockPropsForGroup(group: string): Array<{
+        key: string;
+        schema: ComponentDefinition['props'][string];
+    }>;
+    getBlockPropertyValue(key: string): string;
+    updateBlockProperty(key: string, event: Event): void;
+    updateBlockBooleanProperty(key: string, event: Event): void;
+    openFilePicker(mediaType: 'IMAGE' | 'VIDEO', key: string, context: 'block' | 'section'): void;
+    closeFilePicker(): void;
+    onFileSelected(url: string): void;
+    clearBlockProperty(key: string): void;
+    clearSectionProperty(key: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VisualEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VisualEditorComponent, "lib-visual-editor", never, {}, {}, never, never, true, never>;
+}
+
+interface ShopifyFile {
+    id: string;
+    alt: string;
+    url: string;
+    filename: string;
+    mediaType: 'IMAGE' | 'VIDEO';
+    mimeType: string;
+    width?: number;
+    height?: number;
+    createdAt: string;
+}
+interface ShopifyFilesPage {
+    files: ShopifyFile[];
+    pageInfo: {
+        hasNextPage: boolean;
+        endCursor: string | null;
+    };
+}
+declare const FILES_QUERY = "\n  query GetFiles($first: Int!, $after: String, $query: String) {\n    files(first: $first, after: $after, query: $query) {\n      edges {\n        node {\n          ... on MediaImage {\n            id\n            alt\n            createdAt\n            mimeType\n            image {\n              url\n              width\n              height\n            }\n            originalSource {\n              fileSize\n            }\n          }\n          ... on Video {\n            id\n            alt\n            createdAt\n            filename\n            originalSource {\n              mimeType\n              url\n            }\n            sources {\n              url\n              mimeType\n              width\n              height\n            }\n          }\n        }\n        cursor\n      }\n      pageInfo {\n        hasNextPage\n        endCursor\n      }\n    }\n  }\n";
+declare class ShopifyFilesService {
+    private readonly client;
+    getFiles(mediaType: 'IMAGE' | 'VIDEO', search?: string, first?: number, after?: string): Observable<ShopifyFilesPage>;
+    private mapNode;
+    private extractFilename;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShopifyFilesService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShopifyFilesService>;
+}
+
+declare class ShopifyFilePickerComponent implements OnInit, OnDestroy {
+    readonly mediaType: _angular_core.InputSignal<"IMAGE" | "VIDEO">;
+    readonly currentValue: _angular_core.InputSignal<string>;
+    readonly fileSelected: _angular_core.OutputEmitterRef<string>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private readonly filesService;
+    private readonly destroy$;
+    private readonly searchSubject;
+    private readonly searchInput;
+    private readonly scrollContainer;
+    readonly files: _angular_core.WritableSignal<ShopifyFile[]>;
+    readonly selectedFile: _angular_core.WritableSignal<ShopifyFile | null>;
+    readonly isLoading: _angular_core.WritableSignal<boolean>;
+    readonly error: _angular_core.WritableSignal<string | null>;
+    readonly searchTerm: _angular_core.WritableSignal<string>;
+    private endCursor;
+    private hasNextPage;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    loadFiles(): void;
+    onSearchInput(event: Event): void;
+    onScroll(): void;
+    selectFile(file: ShopifyFile): void;
+    selectAndConfirm(file: ShopifyFile): void;
+    confirmSelection(): void;
+    close(): void;
+    onBackdropClick(event: Event): void;
+    getThumbnailUrl(url: string): string;
+    private loadMore;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShopifyFilePickerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShopifyFilePickerComponent, "lib-shopify-file-picker", never, { "mediaType": { "alias": "mediaType"; "required": true; "isSignal": true; }; "currentValue": { "alias": "currentValue"; "required": false; "isSignal": true; }; }, { "fileSelected": "fileSelected"; "closed": "closed"; }, never, never, true, never>;
+}
+
+/**
+ * Page manager component for listing, creating, and managing pages
+ */
+declare class PageManagerComponent implements OnInit {
+    private readonly facade;
+    private readonly navigation;
+    readonly pages: _angular_core.WritableSignal<PageSummary[]>;
+    readonly isLoading: _angular_core.WritableSignal<boolean>;
+    readonly error: _angular_core.WritableSignal<string | null>;
+    readonly showCreateDialog: _angular_core.WritableSignal<boolean>;
+    readonly newPageTitle: _angular_core.WritableSignal<string>;
+    readonly newPageSlug: _angular_core.WritableSignal<string>;
+    readonly isCreating: _angular_core.WritableSignal<boolean>;
+    readonly createError: _angular_core.WritableSignal<string | null>;
+    readonly pageToDelete: _angular_core.WritableSignal<PageSummary | null>;
+    readonly isDeleting: _angular_core.WritableSignal<boolean>;
+    ngOnInit(): void;
+    loadPages(): void;
+    openCreateDialog(): void;
+    closeCreateDialog(): void;
+    onTitleInput(event: Event): void;
+    onSlugInput(event: Event): void;
+    createPage(event: Event): void;
+    editPage(pageId: string): void;
+    duplicatePage(pageId: string, event: Event): void;
+    confirmDelete(page: PageSummary, event: Event): void;
+    cancelDelete(): void;
+    deletePage(): void;
+    formatDate(dateString: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageManagerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PageManagerComponent, "lib-page-manager", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Token para inyectar el dominio de la tienda.
+ * Debe ser configurado por la aplicación que instala el editor.
+ *
+ * Ejemplo de uso:
+ * ```typescript
+ * providers: [
+ *   { provide: STORE_DOMAIN, useValue: 'nike.com' }
+ * ]
+ * ```
+ *
+ * Si no se provee, el servicio intentará detectar el dominio desde window.location.hostname
+ */
+declare const STORE_DOMAIN: InjectionToken<string>;
+interface Shop {
+    id: string;
+    name: string;
+    shopify_domain: string;
+}
+interface ShopUser {
+    email: string;
+    role: 'owner' | 'admin' | 'reader';
+}
+interface ShopLicense {
+    tier: 'starter' | 'growth' | 'enterprise';
+    expires_at: string | null;
+    active: boolean;
+}
+interface ShopAuthData {
+    shop: Shop | null;
+    user: ShopUser | null;
+    license: ShopLicense | null;
+}
+interface ShopAuthError {
+    code: string;
+    message: string;
+}
+declare class ShopAuthService {
+    private http;
+    private config;
+    private authService;
+    private storeDomainConfig;
+    private _shop;
+    private _user;
+    private _license;
+    private _loading;
+    private _error;
+    private _initialized;
+    readonly shop: _angular_core.Signal<Shop | null>;
+    readonly user: _angular_core.Signal<ShopUser | null>;
+    readonly license: _angular_core.Signal<ShopLicense | null>;
+    readonly loading: _angular_core.Signal<boolean>;
+    readonly error: _angular_core.Signal<ShopAuthError | null>;
+    readonly initialized: _angular_core.Signal<boolean>;
+    readonly shopId: _angular_core.Signal<string | null>;
+    readonly shopName: _angular_core.Signal<string | null>;
+    readonly shopifyDomain: _angular_core.Signal<string | null>;
+    readonly userEmail: _angular_core.Signal<string | null>;
+    readonly userRole: _angular_core.Signal<"owner" | "admin" | "reader" | null>;
+    readonly isOwner: _angular_core.Signal<boolean>;
+    readonly isAdmin: _angular_core.Signal<boolean>;
+    readonly canEdit: _angular_core.Signal<boolean>;
+    readonly licenseTier: _angular_core.Signal<"starter" | "growth" | "enterprise" | null>;
+    readonly licenseActive: _angular_core.Signal<boolean>;
+    readonly licenseExpiresAt: _angular_core.Signal<string | null>;
+    readonly hasAccess: _angular_core.Signal<boolean>;
+    readonly daysRemaining: _angular_core.Signal<number | null>;
+    readonly isLicenseExpiringSoon: _angular_core.Signal<boolean>;
+    /**
+     * Obtiene el dominio actual.
+     * Prioridad:
+     * 1. STORE_DOMAIN token (inyectado)
+     * 2. Query param ?shop= (solo en localhost)
+     * 3. window.location.hostname
+     */
+    getCurrentDomain(): string;
+    /**
+     * Autentica al usuario para el dominio actual.
+     * Esta es la función principal que debe llamarse al cargar la app.
+     */
+    authenticate(): Promise<ShopAuthData>;
+    /**
+     * Limpia el estado (para logout)
+     */
+    clear(): void;
+    /**
+     * Refresca la autenticación
+     */
+    refresh(): Promise<ShopAuthData>;
+    /**
+     * Verifica si el error actual indica que el usuario no tiene acceso
+     */
+    isNoAccessError(): boolean;
+    /**
+     * Verifica si el error actual indica que la licencia expiró
+     */
+    isLicenseExpiredError(): boolean;
+    /**
+     * Verifica si el usuario está inactivo
+     */
+    isUserInactiveError(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShopAuthService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShopAuthService>;
+}
+
+declare class LicenseGuardComponent {
+    shopAuthService: ShopAuthService;
+    showExpirationWarning: _angular_core.InputSignal<boolean>;
+    subscribe: _angular_core.OutputEmitterRef<void>;
+    renew: _angular_core.OutputEmitterRef<void>;
+    reauth: _angular_core.OutputEmitterRef<void>;
+    retry: _angular_core.OutputEmitterRef<void>;
+    onSubscribe(): void;
+    onRenew(): void;
+    onReauth(): void;
+    onRetry(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LicenseGuardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LicenseGuardComponent, "lib-license-guard", never, { "showExpirationWarning": { "alias": "showExpirationWarning"; "required": false; "isSignal": true; }; }, { "subscribe": "subscribe"; "renew": "renew"; "reauth": "reauth"; "retry": "retry"; }, never, ["*"], true, never>;
+}
+
+declare class LoginComponent {
+    private authService;
+    private router;
+    loginSuccess: _angular_core.OutputEmitterRef<void>;
+    email: _angular_core.WritableSignal<string>;
+    password: _angular_core.WritableSignal<string>;
+    error: _angular_core.WritableSignal<string | null>;
+    loading: _angular_core.WritableSignal<boolean>;
+    isSignUp: _angular_core.WritableSignal<boolean>;
+    showPassword: _angular_core.WritableSignal<boolean>;
+    toggleMode(): void;
+    togglePassword(): void;
+    onSubmit(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoginComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoginComponent, "lib-login", never, {}, { "loginSuccess": "loginSuccess"; }, never, never, true, never>;
+}
+
+type ViewState = 'loading' | 'no-store' | 'license-expired';
+declare class ActivateLicenseComponent implements OnInit {
+    shopAuthService: ShopAuthService;
+    viewState: _angular_core.Signal<ViewState>;
+    ngOnInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActivateLicenseComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ActivateLicenseComponent, "lib-activate-license", never, {}, {}, never, never, true, never>;
+}
+
+interface SupabaseConfig {
+    supabaseUrl: string;
+    supabaseAnonKey: string;
+}
+declare const SUPABASE_CONFIG: InjectionToken<SupabaseConfig>;
+declare class SupabaseAuthService implements OnDestroy {
+    private config;
+    private supabase;
+    private supabasePromise;
+    private authSubscription;
+    private _session;
+    private _user;
+    private _loading;
+    private _error;
+    private _initialized;
+    readonly session: _angular_core.Signal<Session | null>;
+    readonly user: _angular_core.Signal<User | null>;
+    readonly loading: _angular_core.Signal<boolean>;
+    readonly error: _angular_core.Signal<string | null>;
+    readonly initialized: _angular_core.Signal<boolean>;
+    readonly isAuthenticated: _angular_core.Signal<boolean>;
+    readonly accessToken: _angular_core.Signal<string | null>;
+    readonly userEmail: _angular_core.Signal<string | null>;
+    private getSupabaseClient;
+    private initializeClient;
+    ensureInitialized(): Promise<void>;
+    signInWithPassword(email: string, password: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    signUp(email: string, password: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    signOut(): Promise<void>;
+    resetPassword(email: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    getClient(): Promise<SupabaseClient | null>;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SupabaseAuthService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SupabaseAuthService>;
+}
+
+declare class AppShellComponent {
+    authService: SupabaseAuthService;
+    shopAuthService: ShopAuthService;
+    loggedOut: _angular_core.OutputEmitterRef<void>;
+    logout(): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AppShellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AppShellComponent, "lib-app-shell", never, {}, { "loggedOut": "loggedOut"; }, never, ["*"], true, never>;
+}
+
+declare class NoAccessComponent {
+    backToLogin: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NoAccessComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NoAccessComponent, "ke-no-access", never, {}, { "backToLogin": "backToLogin"; }, never, never, true, never>;
+}
+
+declare class LicenseExpiredComponent {
+    backToLogin: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LicenseExpiredComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LicenseExpiredComponent, "ke-license-expired", never, {}, { "backToLogin": "backToLogin"; }, never, never, true, never>;
+}
+
+/**
+ * Injection token to enable in-memory page storage (for development)
+ * When false (default), uses Shopify metafields via GraphQL API
+ */
+declare const USE_IN_MEMORY_PAGES: InjectionToken<boolean>;
+/**
+ * Injection token for page environment (metafield key prefix).
+ * Default is 'production'.
+ */
+declare const PAGE_ENVIRONMENT: InjectionToken<string>;
+declare class PageService {
+    private readonly useInMemory;
+    private readonly pageEnvironment;
+    private readonly memoryRepo;
+    private readonly shopifyRepo;
+    private resolveEnvironment;
+    /**
+     * Get all pages (summaries only for listing)
+     */
+    getPages(environment?: string): Observable<PageSummary[]>;
+    /**
+     * Get a single page by ID (full content)
+     */
+    getPage(id: string, environment?: string): Observable<Page>;
+    /**
+     * Get a published page by slug (for public rendering)
+     */
+    getPublishedPageBySlug(slug: string, environment?: string): Observable<Page>;
+    /**
+     * Create a new page
+     */
+    createPage(request: CreatePageRequest, environment?: string): Observable<Page>;
+    /**
+     * Update an existing page
+     */
+    updatePage(id: string, request: UpdatePageRequest, environment?: string): Observable<Page>;
+    /**
+     * Delete a page
+     */
+    deletePage(id: string, environment?: string): Observable<void>;
+    /**
+     * Publish a page (changes status to 'published')
+     */
+    publishPage(id: string, request: PublishPageRequest, environment?: string): Observable<Page>;
+    /**
+     * Unpublish a page (changes status to 'draft')
+     */
+    unpublishPage(id: string, request: PublishPageRequest, environment?: string): Observable<Page>;
+    /**
+     * Duplicate an existing page
+     */
+    duplicatePage(id: string, environment?: string): Observable<Page>;
+    /**
+     * Delete all pages for a given environment
+     */
+    deletePagesByEnvironment(environment?: string): Observable<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PageService>;
+}
+
+interface ShopifyAppConfig {
+    appUrl: string;
+}
+interface ShopifyTokenResponse {
+    accessToken: string;
+    shopifyDomain: string;
+}
+type TokenErrorCode = 'NOT_AUTHENTICATED' | 'NO_ACTIVE_STORE' | 'TOKEN_FETCH_FAILED' | 'SESSION_EXPIRED' | 'NO_STORE_ACCESS' | 'NETWORK_ERROR' | 'UNKNOWN_ERROR';
+interface TokenError {
+    code: TokenErrorCode;
+    message: string;
+    status?: number;
+}
+declare const SHOPIFY_APP_CONFIG: InjectionToken<ShopifyAppConfig>;
+declare class ShopifyTokenService {
+    private readonly http;
+    private readonly config;
+    private readonly authService;
+    private readonly shopAuthService;
+    private readonly CACHE_TTL_MS;
+    private readonly tokenCache;
+    private readonly _currentToken;
+    private readonly _currentDomain;
+    private readonly _loading;
+    private readonly _error;
+    private pendingRequest;
+    readonly currentToken: _angular_core.Signal<string | null>;
+    readonly currentDomain: _angular_core.Signal<string | null>;
+    readonly loading: _angular_core.Signal<boolean>;
+    readonly error: _angular_core.Signal<TokenError | null>;
+    readonly hasToken: _angular_core.Signal<boolean>;
+    readonly isReady: _angular_core.Signal<boolean>;
+    getToken(): Observable<ShopifyTokenResponse>;
+    getTokenForDomain(shopifyDomain: string): Observable<ShopifyTokenResponse>;
+    refreshToken(): Observable<ShopifyTokenResponse>;
+    invalidateCache(shopifyDomain?: string): void;
+    clear(): void;
+    private fetchToken;
+    private getCachedToken;
+    private setCachedToken;
+    private handleHttpError;
+    private createError;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShopifyTokenService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShopifyTokenService>;
+}
+
+type GraphQLErrorCode = 'GRAPHQL_ERROR' | 'EMPTY_RESPONSE' | 'UNAUTHORIZED' | 'FORBIDDEN' | 'RATE_LIMIT' | 'SERVER_ERROR' | 'NETWORK_ERROR' | 'HTTP_ERROR' | 'TOKEN_ERROR' | 'UNKNOWN_ERROR';
+interface GraphQLError {
+    code: GraphQLErrorCode;
+    message: string;
+    status?: number;
+    errors?: Array<{
+        message: string;
+    }>;
+    original?: unknown;
+}
+declare class ShopifyGraphQLClient {
+    private readonly http;
+    private readonly authService;
+    private readonly shopAuthService;
+    private readonly config;
+    query<T>(query: string, variables?: Record<string, unknown>): Observable<T>;
+    mutate<T>(mutation: string, variables?: Record<string, unknown>): Observable<T>;
+    private executeOperation;
+    private handleResponse;
+    private handleHttpError;
+    private createError;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShopifyGraphQLClient, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShopifyGraphQLClient>;
+}
+
+declare const NAMESPACE = "kustomizer";
+declare const INDEX_KEY = "pages_index";
+declare const MAX_METAFIELD_SIZE: number;
+declare const GET_SHOP_METAFIELD_QUERY = "\n  query GetShopMetafield($namespace: String!, $key: String!) {\n    shop {\n      id\n      metafield(namespace: $namespace, key: $key) {\n        id\n        value\n        createdAt\n        updatedAt\n      }\n    }\n  }\n";
+declare const SET_METAFIELD_MUTATION = "\n  mutation SetMetafield($metafields: [MetafieldsSetInput!]!) {\n    metafieldsSet(metafields: $metafields) {\n      metafields {\n        id\n        namespace\n        key\n        value\n      }\n      userErrors {\n        field\n        message\n      }\n    }\n  }\n";
+declare const DELETE_METAFIELDS_MUTATION = "\n  mutation DeleteMetafields($metafields: [MetafieldIdentifierInput!]!) {\n    metafieldsDelete(metafields: $metafields) {\n      deletedMetafields {\n        key\n        namespace\n      }\n      userErrors {\n        field\n        message\n      }\n    }\n  }\n";
+declare const GET_SHOP_ID_QUERY = "\n  query GetShopId {\n    shop {\n      id\n    }\n  }\n";
+declare class ShopifyMetafieldRepository {
+    private readonly client;
+    private resolveEnvironment;
+    private buildIndexKey;
+    private buildPageKey;
+    getMetafield(namespace: string, key: string): Observable<Metafield | null>;
+    setMetafield(namespace: string, key: string, value: any, ownerId: string): Observable<Metafield>;
+    deleteMetafield(namespace: string, key: string): Observable<void>;
+    getShopId(): Observable<string>;
+    getPageIndex(environment?: string): Observable<PagesIndex>;
+    updatePageIndex(index: PagesIndex, environment?: string): Observable<PagesIndex>;
+    getPageMetafield(pageId: string, environment?: string): Observable<Page | null>;
+    setPageMetafield(pageId: string, page: Page, environment?: string): Observable<Page>;
+    deletePageMetafield(pageId: string, environment?: string): Observable<void>;
+    resetPageIndex(environment?: string): Observable<PagesIndex>;
+    validateSize(data: any): {
+        valid: boolean;
+        size: number;
+        percentUsed: number;
+    };
+    private getDefaultIndex;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShopifyMetafieldRepository, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShopifyMetafieldRepository>;
+}
+
+declare class PageShopifyRepository {
+    private readonly metafieldRepo;
+    private resolveEnvironment;
+    getPages(environment?: string): Observable<PageSummary[]>;
+    getPage(id: string, environment?: string): Observable<Page>;
+    getPublishedPageBySlug(slug: string, environment?: string): Observable<Page>;
+    createPage(request: CreatePageRequest, environment?: string): Observable<Page>;
+    updatePage(id: string, request: UpdatePageRequest, environment?: string): Observable<Page>;
+    deletePage(id: string, environment?: string): Observable<void>;
+    publishPage(id: string, request: PublishPageRequest, environment?: string): Observable<Page>;
+    unpublishPage(id: string, request: PublishPageRequest, environment?: string): Observable<Page>;
+    duplicatePage(id: string, environment?: string): Observable<Page>;
+    deletePagesByEnvironment(environment?: string): Observable<void>;
+    private validateUniqueSlug;
+    private generateUniqueSlug;
+    private addPageToIndex;
+    private updatePageInIndex;
+    private removePageFromIndex;
+    private mapIndexEntryToSummary;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PageShopifyRepository, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PageShopifyRepository>;
+}
+
+interface TeamMember {
+    email: string;
+    role: 'owner' | 'admin' | 'reader';
+    status: 'active' | 'inactive' | 'suspended';
+    invited_by: string | null;
+    joined_at: string;
+    is_current_user: boolean;
+}
+interface PendingInvitation {
+    id: string;
+    email: string;
+    role: 'admin' | 'reader';
+    invited_by: string;
+    created_at: string;
+    expires_at: string;
+    is_expired: boolean;
+}
+interface CurrentUser {
+    email: string;
+    role: string;
+    can_invite: boolean;
+    can_remove_members: boolean;
+}
+interface TeamData {
+    shop: {
+        id: string;
+        name: string;
+        shopify_domain: string;
+        allowed_domains: string[];
+    };
+    members: TeamMember[];
+    invitations: PendingInvitation[];
+    current_user: CurrentUser;
+    summary: {
+        total_members: number;
+        pending_invitations: number;
+    };
+}
+interface InviteResult {
+    invitation_id: string;
+    token: string;
+    expires_at: string;
+    email: string;
+    role: string;
+}
+interface AcceptInvitationResult {
+    success: boolean;
+    shop: {
+        id: string;
+        name: string;
+        shopify_domain: string;
+    };
+    role: string;
+    message: string;
+}
+declare class ShopTeamService {
+    private http;
+    private config;
+    private authService;
+    private shopAuthService;
+    private _team;
+    private _loading;
+    private _error;
+    readonly team: _angular_core.Signal<TeamData | null>;
+    readonly loading: _angular_core.Signal<boolean>;
+    readonly error: _angular_core.Signal<string | null>;
+    readonly members: _angular_core.Signal<TeamMember[]>;
+    readonly invitations: _angular_core.Signal<PendingInvitation[]>;
+    readonly currentUser: _angular_core.Signal<CurrentUser | null>;
+    readonly activeMembers: _angular_core.Signal<TeamMember[]>;
+    readonly pendingInvitations: _angular_core.Signal<PendingInvitation[]>;
+    readonly canInvite: _angular_core.Signal<boolean>;
+    /**
+     * Carga el equipo de la shop actual
+     */
+    loadTeam(): Promise<TeamData | null>;
+    /**
+     * Invita a un usuario a la shop
+     */
+    inviteUser(email: string, role: 'admin' | 'reader', message?: string): Promise<InviteResult | null>;
+    /**
+     * Acepta una invitación (usado cuando un usuario hace click en el link de invitación)
+     */
+    acceptInvitation(invitationToken: string): Promise<AcceptInvitationResult | null>;
+    /**
+     * Genera el URL de invitación (para copiar/compartir)
+     */
+    getInvitationUrl(token: string, baseUrl?: string): string;
+    /**
+     * Limpia el estado
+     */
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShopTeamService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShopTeamService>;
+}
+
+declare const authGuard: CanActivateFn;
+declare const noAuthGuard: CanActivateFn;
+
+declare const licenseGuard: CanActivateFn;
+declare const noLicenseGuard: CanActivateFn;
+
+/**
+ * Guard que verifica:
+ * 1. Usuario autenticado
+ * 2. Usuario tiene acceso a la shop del dominio actual
+ * 3. Licencia activa
+ *
+ * Redirige a:
+ * - /login si no está autenticado
+ * - /no-access si no tiene acceso a la shop
+ * - /license-expired si la licencia expiró
+ */
+declare const shopAuthGuard: CanActivateFn;
+/**
+ * Guard que solo permite acceso si el usuario NO tiene acceso a una shop.
+ * Útil para páginas como /login que no deberían ser accesibles si ya tienes acceso.
+ */
+declare const noShopAuthGuard: CanActivateFn;
+/**
+ * Guard que verifica que el usuario tenga rol de admin o owner.
+ * Requiere que shopAuthGuard se haya ejecutado primero.
+ */
+declare const shopAdminGuard: CanActivateFn;
+/**
+ * Guard que verifica que el usuario pueda editar (owner o admin).
+ * Los readers solo pueden ver, no editar.
+ */
+declare const shopEditorGuard: CanActivateFn;
+
+declare class DragDropService {
+    private readonly store;
+    private readonly registry;
+    private readonly sections;
+    readonly dragItem: _angular_core.WritableSignal<DragItem | null>;
+    readonly dropTarget: _angular_core.WritableSignal<DropTarget | null>;
+    readonly isDragging: _angular_core.Signal<boolean>;
+    startDrag(item: DragItem, event: DragEvent): void;
+    endDrag(): void;
+    updateDropTarget(target: DropTarget | null): void;
+    computeDropZone(event: DragEvent, element: HTMLElement, canDropInside: boolean): DropZone;
+    validateDrop(item: DragItem, target: DropTarget): boolean;
+    executeDrop(): void;
+    private executeSectionDrop;
+    private executeBlockDrop;
+    private isDropOnSelf;
+    private wouldCreateCircular;
+    private isTypeAllowedInSlot;
+    private findElementInTree;
+    private isDescendant;
+    private pathsEqual;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DragDropService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DragDropService>;
+}
+
+declare class VisualEditor {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VisualEditor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VisualEditor, "lib-visual-editor", never, {}, {}, never, never, true, never>;
+}
+
+export { ActivateLicenseComponent, AppShellComponent, BlockTreeItemComponent, ComponentRegistryService, DEFAULT_ROUTER_NAVIGATION_CONFIG, DEFAULT_VISUAL_EDITOR_CONFIG, DELETE_METAFIELDS_MUTATION, DefaultRouterNavigationService, DragDropService, DynamicRendererComponent, EDITOR_COMPONENT_DEFINITIONS, FILES_QUERY, GET_SHOP_ID_QUERY, GET_SHOP_METAFIELD_QUERY, INDEX_KEY, InputPageLoadingStrategy, LicenseExpiredComponent, LicenseGuardComponent, LoginComponent, MAX_METAFIELD_SIZE, NAMESPACE, NoAccessComponent, PAGE_ENVIRONMENT, PageLoadingStrategy, PageManagerComponent, PageService, PageShopifyRepository, ROUTER_NAVIGATION_CONFIG, RoutePageLoadingStrategy, SET_METAFIELD_MUTATION, SHOPIFY_API_VERSION, SHOPIFY_APP_CONFIG, SHOPIFY_CONFIG, STORE_DOMAIN, SUPABASE_CONFIG, ShopAuthService, ShopTeamService, ShopifyFilePickerComponent, ShopifyFilesService, ShopifyGraphQLClient, ShopifyMetafieldRepository, ShopifyTokenService, SlotRendererComponent, SupabaseAuthService, USE_IN_MEMORY_PAGES, VISUAL_EDITOR_CONFIG, VISUAL_EDITOR_FEATURE_KEY, VisualEditor, VisualEditorActions, VisualEditorComponent, VisualEditorFacade, VisualEditorNavigation, authGuard, initialVisualEditorState, licenseGuard, noAuthGuard, noLicenseGuard, noShopAuthGuard, provideEditorComponents, provideVisualEditor, provideVisualEditorStore, selectBlocksForSection, selectBlocksForSlot, selectCanRedo, selectCanUndo, selectCurrentPage, selectCurrentPageId, selectCurrentPageSlug, selectCurrentPageStatus, selectCurrentPageTitle, selectCurrentPageVersion, selectDraggedElementId, selectElementById, selectHistory, selectHistoryIndex, selectHistoryLength, selectIsDirty, selectIsDragging, selectIsPageLoaded, selectLastAction, selectSectionById, selectSections, selectSelectedBlock, selectSelectedBlockSlotName, selectSelectedElement, selectSelectedElementId, selectSelectedElementType, selectSelectedSection, selectSelectedSectionId, selectSelectedSectionType, selectVisualEditorState, shopAdminGuard, shopAuthGuard, shopEditorGuard, visualEditorReducer };
+export type { AcceptInvitationResult, BlockPickerTarget, BlockTreeContext, ComponentCategory, ComponentDefinition, ComponentPreset, ConfirmDialogOptions, CreatePageRequest, CurrentUser, DragItem, DragItemKind, DropTarget, DropZone, EditorElement, EditorSection, GraphQLError, GraphQLErrorCode, HistoryEntry, InviteResult, Metafield, Page, PageContext, PageIndexEntry, PageStatus, PageSummary, PagesIndex, PendingInvitation, PresetBlockConfig, PropCondition, PropSchema, PropSchemaMap, PropType, PropValidation, PublishPageRequest, ResolvedPreset, RouterNavigationConfig, SelectOption, Shop, ShopAuthData, ShopAuthError, ShopLicense, ShopUser, ShopifyAppConfig, ShopifyConfig, ShopifyFile, ShopifyFilesPage, ShopifyTokenResponse, SlotConstraints, SlotDefinition, SupabaseConfig, TeamData, TeamMember, TokenError, TokenErrorCode, UpdatePageRequest, VisualEditorConfig, VisualEditorNavigationTarget, VisualEditorState };