@vectoriox/iox-builder 1.0.0

package/types/vectoriox-iox-builder.d.ts

@@ -0,0 +1,1209 @@
+import * as i0 from '@angular/core';
+import { ComponentRef, Type, ChangeDetectorRef, OnInit, AfterViewInit, OnChanges, OnDestroy, EventEmitter, ElementRef, ApplicationRef, SimpleChanges, ViewContainerRef, Injector, InjectionToken, TemplateRef, AfterContentInit, QueryList } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Subject, Subscription, BehaviorSubject } from 'rxjs';
+import * as i20 from 'primeng/popover';
+import { Popover } from 'primeng/popover';
+import { ActivatedRoute } from '@angular/router';
+import * as i17 from '@angular/cdk/drag-drop';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import * as i15 from '@angular/common';
+import * as i16 from '@angular/forms';
+import * as i18 from 'primeng/accordion';
+import * as i19 from 'primeng/button';
+import * as i21 from 'primeng/inputtext';
+import * as i22 from 'primeng/select';
+import * as i23 from 'primeng/tooltip';
+import * as i24 from 'primeng/dialog';
+import * as i25 from '@vectoriox/iox-ui';
+
+declare enum StyleCategory {
+    Layout = "Layout",
+    Size = "Size",
+    Typography = "Typography",
+    Spacing = "Spacing",
+    Border = "Border",
+    Position = "Position",
+    Background = "Background",
+    Effects = "Effects",
+    Dimensions = "Dimensions"
+}
+interface IoxBinding {
+    prop: string;
+    source: string;
+    path: string;
+    fallback?: any;
+}
+/**
+ * When mode=single: looks up a single CMS item by matching a schema field
+ * against a URL path param (e.g. /project/:projectId → field _id).
+ * `defaultId` is used as a fallback value in the builder preview when no
+ * live route is active.
+ */
+interface DsFilterByRouteParam {
+    field: string;
+    routeParam: string;
+    defaultId?: string;
+}
+/**
+ * When mode=query: each entry maps a schema field to a URL query string
+ * key (e.g. ?status=active → field "status").
+ * `defaultValue` is used as a fallback in the builder preview.
+ */
+interface DsFilterByQueryParam {
+    field: string;
+    queryParam: string;
+    defaultValue?: string;
+}
+interface IoxDataSource {
+    id: string;
+    type: 'cms' | 'internal-api' | 'external-api' | 'static';
+    mode: 'single' | 'query';
+    alias: string;
+    request: {
+        method?: 'GET' | 'POST';
+        endpoint?: string;
+        cms?: {
+            contentType: string;
+            filter?: any;
+            limit?: number;
+            sort?: any;
+            /** Single-result lookup: match field against a route path param */
+            filterByRouteParam?: DsFilterByRouteParam;
+            /** Array-result filtering: match fields against URL query params */
+            filterByQueryParams?: DsFilterByQueryParam[];
+        };
+        params?: Record<string, any>;
+    };
+}
+type InteractionTrigger = 'pageLoad' | 'click' | 'hover' | 'viewportEnter' | 'scrollProgress';
+type InteractionActionType = 'fadeIn' | 'fadeOut' | 'moveUp' | 'moveDown' | 'moveLeft' | 'moveRight' | 'scaleIn' | 'scaleOut' | 'rotate' | 'show' | 'hide' | 'toggleVisibility';
+interface InteractionAction {
+    type: InteractionActionType;
+    /** 'self' targets the node that owns the interaction; otherwise a node ID. */
+    target: 'self' | string;
+    /** Duration in milliseconds. */
+    duration: number;
+    /** Delay in milliseconds before the action starts. */
+    delay: number;
+    easing: 'linear' | 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out';
+    /** Extra parameters (e.g. { distance: 20 } for move actions). */
+    params?: Record<string, any>;
+    /** If true, the action only plays once (relevant for viewport/scroll triggers). */
+    once?: boolean;
+}
+interface IoxInteraction {
+    id: string;
+    trigger: InteractionTrigger;
+    actions: InteractionAction[];
+}
+declare const TRIGGER_OPTIONS: {
+    value: InteractionTrigger;
+    label: string;
+    icon: string;
+}[];
+declare const ACTION_TYPE_OPTIONS: {
+    value: InteractionActionType;
+    label: string;
+}[];
+interface ComponentNode {
+    id?: string;
+    /**
+     * The CSS class key (`iox-node-{styleId}`) used by the style engine.
+     * Set on clone nodes to point back to the original template node's id,
+     * so all repeated rows share a single CSS rule.
+     * Absent on original (non-clone) nodes — they use `id` directly.
+     */
+    styleId?: string;
+    type: string;
+    inputs?: Record<string, any>;
+    traits?: ComponentTrait[];
+    styleTraits?: StyleTraitGroup[];
+    bindings?: IoxBinding[];
+    interactions?: IoxInteraction[];
+    children?: ComponentNode[];
+}
+declare enum TraitInputType {
+    Text = "text",
+    Number = "number",
+    Select = "select",
+    Checkbox = "checkbox",
+    Color = "colorPicker",
+    DirectionalSize = "directionalSize",
+    SelectButton = "selectButton",
+    Scrub = "scrub",
+    Icon = "icon",
+    Media = "media",
+    FontFamily = "fontFamily"
+}
+interface TraitOptionMap {
+    [key: string]: any;
+}
+/** Named label/value pair for select options where the display label differs from the CSS value. */
+interface TraitSelectOption {
+    label: string;
+    value: string;
+}
+interface QuadSizeSegment {
+    key: string;
+    icon: string;
+    ariaLabel?: string;
+}
+/** Conditional visibility: this trait only shows when the named sibling trait matches one of the given values. */
+interface TraitShowCondition {
+    /** name of another trait in the same style group */
+    trait: string;
+    /** one value or an array of values that make this trait visible */
+    values: string | string[];
+}
+interface ComponentTrait {
+    name: string;
+    label: string;
+    type: TraitInputType;
+    options?: string[] | TraitSelectOption[] | TraitOptionMap;
+    default?: any;
+    inline?: boolean;
+    /** When set, this trait is hidden unless the named sibling trait has one of the specified values. */
+    showWhen?: TraitShowCondition;
+}
+type StyleTrait = ComponentTrait;
+interface StyleTraitGroup {
+    category: string;
+    traits: ComponentTrait[];
+}
+declare function generateNodeId(): string;
+declare class ComponentConfig {
+    id: string;
+    type: string;
+    selector: string;
+    icon: string;
+    category: string;
+    inputs: Record<string, any>;
+    traits: ComponentTrait[];
+    styleTraits: StyleTraitGroup[];
+    /** Layout components (e.g. Section) set this to []. Leaf components leave it undefined.
+     *  RenderDirective uses `node.children !== undefined` to detect layout components. */
+    children?: ComponentNode[];
+    constructor(type: string, selector: string, icon?: string, category?: string);
+    /** Override specific trait defaults after styleTraits are set.
+     *  Call this at the end of each subclass constructor. */
+    protected applyStyleDefaults(defaults: Record<string, any>): void;
+}
+declare class TraitConfig {
+    name: string;
+    label: string;
+    type: TraitInputType;
+    options?: string[] | TraitSelectOption[] | TraitOptionMap;
+    default?: any;
+    inline?: boolean;
+    showWhen?: TraitShowCondition;
+    constructor(name: string, label: string, type: TraitInputType, options?: string[] | TraitSelectOption[] | TraitOptionMap, defaultValue?: any, inline?: boolean, showWhen?: TraitShowCondition);
+}
+
+declare class GroupStyleConfig {
+    category: string;
+    traits: TraitConfig[];
+    constructor(category: string, traits: TraitConfig[]);
+}
+declare const UNITS_ALL: string[];
+declare const UNITS_NO_VW: string[];
+declare const UNITS_FIXED: string[];
+declare const UNITS_DEG: string[];
+declare function resolveTraitControllerType(type: TraitInputType): string;
+declare function resolveTraitOptions(trait: ComponentTrait): any;
+
+declare enum PanelTypes {
+    BINDINGS = "Bindings",
+    STYLES = "Styles",
+    PAGE = "Page"
+}
+type RouteAnimationPreset = 'none' | 'fade' | 'slideUp' | 'slideDown' | 'zoomIn' | 'zoomOut' | 'blurIn' | 'flip';
+declare const ROUTE_ANIMATION_OPTIONS: {
+    label: string;
+    value: RouteAnimationPreset;
+    description: string;
+}[];
+declare const EASING_OPTIONS: {
+    label: string;
+    value: string;
+}[];
+interface PageStyleSettings {
+    backgroundColor: string;
+    backgroundType: 'solid' | 'gradient' | 'image';
+    backgroundGradient: string;
+    backgroundImage: string;
+    fontFamily: string;
+    textColor: string;
+    maxWidth: string;
+}
+interface PageScrollSettings {
+    enabled: boolean;
+    lerp: number;
+    wheelMultiplier: number;
+    touchMultiplier: number;
+    direction: 'vertical' | 'horizontal';
+    infinite: boolean;
+}
+interface PageRouteAnimationSettings {
+    enter: RouteAnimationPreset;
+    leave: RouteAnimationPreset;
+    duration: number;
+    easing: string;
+}
+interface PageSettings {
+    style: PageStyleSettings;
+    scroll: PageScrollSettings;
+    routeAnimation: PageRouteAnimationSettings;
+}
+declare function defaultPageSettings(): PageSettings;
+declare enum ToolbarAction {
+    SelectParent = "select-parent",
+    Duplicate = "duplicate",
+    Delete = "delete",
+    Play = "play",
+    SaveAsBlock = "save-as-block"
+}
+declare enum NodeAction {
+    Delete = "delete",
+    Duplicate = "duplicate"
+}
+declare enum BuilderMode {
+    Select = "select",
+    Style = "style",
+    Pan = "pan"
+}
+declare enum DeviceMode {
+    Desktop = "desktop",
+    Tablet = "tablet",
+    Mobile = "mobile"
+}
+interface DeviceOption {
+    mode: DeviceMode;
+    label: string;
+    icon: string;
+    width: number;
+}
+declare const DEVICE_OPTIONS: DeviceOption[];
+interface ZoomOption {
+    label: string;
+    value: number | 'fit';
+}
+declare const ZOOM_OPTIONS: ZoomOption[];
+
+interface OverlayBoxSpacing {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+interface OverlayBoxModel {
+    margin: OverlayBoxSpacing;
+    padding: OverlayBoxSpacing;
+    border: OverlayBoxSpacing;
+}
+interface OverlayEntry {
+    element: HTMLElement;
+    componentName: string;
+    boxModel?: OverlayBoxModel;
+    mode: BuilderMode;
+    node?: ComponentNode;
+    componentRef?: ComponentRef<any>;
+}
+
+interface NodeRef {
+    element: HTMLElement;
+    componentRef: ComponentRef<any>;
+}
+declare class OverlayService {
+    private hoverSubject;
+    private selectSubject;
+    private nodeMap;
+    hover$: rxjs.Observable<OverlayEntry | null>;
+    select$: rxjs.Observable<OverlayEntry | null>;
+    private containerElement;
+    private scrollContainerElement;
+    /** Emits the scroll container element whenever it is registered. */
+    scrollContainer$: Subject<HTMLElement>;
+    setContainer(container: HTMLElement | null): void;
+    getContainer(): HTMLElement | null;
+    setScrollContainer(el: HTMLElement | null): void;
+    getScrollContainer(): HTMLElement | null;
+    /**
+     * Resolve the inner styled element.
+     * Builder components apply [ngStyle] on their first child element,
+     * so computed styles (padding, margin) live there — not on the host.
+     */
+    getStyledElement(host: HTMLElement): HTMLElement;
+    registerNode(node: ComponentNode, element: HTMLElement, componentRef: ComponentRef<any>): void;
+    unregisterNode(node: ComponentNode): void;
+    getNodeRef(node: ComponentNode): NodeRef | undefined;
+    /** Return all registered node → ref entries. */
+    getAllNodeEntries(): IterableIterator<[ComponentNode, NodeRef]>;
+    /** Find a registered node whose host element matches the given DOM element. */
+    findNodeByElement(element: HTMLElement): {
+        node: ComponentNode;
+        ref: NodeRef;
+    } | undefined;
+    setHover(element: HTMLElement, componentName: string, mode: BuilderMode): void;
+    clearHover(): void;
+    setSelect(element: HTMLElement, componentName: string, mode: BuilderMode, node?: ComponentNode, componentRef?: ComponentRef<any>): void;
+    clearSelect(): void;
+    refreshSelect(): void;
+    /** Lightweight swap for drag-preview tracking. */
+    updateSelectElement(element: HTMLElement): void;
+    private buildBoxModel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayService>;
+}
+
+declare enum PanelEventTypes {
+    ELEMENT_SELECT = "elementselect",
+    ELEMENT_DESELECT = "elementdeselect",
+    PANEL_SELECTED = "panelselect",
+    PANEL_OPEN = "panelopen",
+    PANEL_CLOSE = "panelclose",
+    BINDING_CHANGED = "bindingchanged",
+    NODE_RENDERED = "noderendered"
+}
+interface PanelEvent {
+    type: PanelEventTypes;
+    data: any;
+}
+declare class PanelEventService {
+    private panelEventSubject;
+    subscribe(next: (panelEvent: PanelEvent) => void): Subscription;
+    emit(type: PanelEventTypes, data?: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PanelEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PanelEventService>;
+}
+
+declare class ComponentRegistryService {
+    private components;
+    getComponent(type: string): Type<any> | null;
+    hasComponent(type: string): boolean;
+    createConfig(type: string): any | null;
+    register(type: string, component: Type<any>, config: any): void;
+    getAll(): {
+        type: string;
+        component: Type<any>;
+        config: any;
+    }[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentRegistryService>;
+}
+
+interface DragPayload {
+    type: 'internal' | 'external';
+    data: ComponentNode | string;
+    sourceId: string | null;
+    sourceIndex: number;
+}
+interface IoxDropEvent {
+    payload: DragPayload;
+    targetId: string;
+    insertIndex: number;
+}
+declare class DragEngineService {
+    private registry;
+    constructor(registry: ComponentRegistryService);
+    handleDrop(children: ComponentNode[], event: IoxDropEvent, dropListId: string, cdr: ChangeDetectorRef, afterDrop?: () => void): void;
+    private ids;
+    private elMap;
+    private dataMap;
+    private cdrMap;
+    private dropCbMap;
+    private postDropMap;
+    readonly ids$: BehaviorSubject<string[]>;
+    readonly isDragging$: BehaviorSubject<boolean>;
+    readonly deepTarget$: BehaviorSubject<string | null>;
+    private _isDragging;
+    private _payload;
+    private _sourceEl;
+    /**
+     * For internal drags: a DOM clone of the dragged element appended to <body>.
+     * Lives outside any CSS transform, so position:fixed works in viewport coords.
+     * For external drags: the label chip overlay.
+     */
+    private _overlay;
+    /** Where on the element the user grabbed it (for accurate ghost positioning). */
+    private _grabOffsetX;
+    private _grabOffsetY;
+    private _lastPointerX;
+    private _lastPointerY;
+    private _deepTargetId;
+    /** Injected overlay div marking the active drop target. */
+    private _targetOverlay;
+    private _indicator;
+    private _indicatorContainerId;
+    private _indicatorIndex;
+    private _indicatorRaf;
+    /** Elements that have temporary FLIP inline styles — cleared on drag end. */
+    private _flipEls;
+    private _scale;
+    /** Called by BuilderComponent whenever the viewport scale changes. */
+    setScale(scale: number): void;
+    private readonly ROOT_ESCAPE_PX;
+    private _rootEscapeActiveFor;
+    private _getEl;
+    registerDropzone(id: string, el: HTMLElement, data: any[], cdr: ChangeDetectorRef, dropCb: (e: IoxDropEvent) => void, postDrop?: () => void): void;
+    unregisterDropzone(id: string, el: HTMLElement): void;
+    registerDraggable(el: HTMLElement, getPayload: () => DragPayload): void;
+    unregisterDraggable(el: HTMLElement): void;
+    getData(id: string): any[] | undefined;
+    getCdr(id: string): ChangeDetectorRef | undefined;
+    invokePostDrop(id: string): void;
+    consumeDeepTarget(): string | null;
+    private _onDragStart;
+    private _onDragMove;
+    private _onDragEnd;
+    private _commitDrop;
+    private _createExternalChip;
+    private _removeOverlay;
+    private _updateDeepTarget;
+    /** Call on every canvas scroll tick to keep the fixed-position drop-target
+     *  overlay aligned with the container element that moved in the viewport. */
+    refreshDragOverlays(): void;
+    private _moveTargetOverlay;
+    private _removeTargetOverlay;
+    private _isRootContainer;
+    /**
+     * Returns true if the dropzone with `childId` is a DOM descendant of the
+     * dropzone with `parentId`. Used to decide whether the cursor was already
+     * "inside" a root section before triggering root-escape.
+     */
+    private _isDescendantDropzone;
+    private _updateIndicator;
+    private _positionIndicator;
+    private _removeIndicator;
+    calcInsertIndex(containerId: string): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragEngineService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DragEngineService>;
+}
+
+/**
+ * Page-scoped registry that holds the current page's data sources.
+ * Scoped to PageUiComponent.providers[] so every builder service
+ * (BindingsComponent, BuilderRepeaterComponent) shares the same instance.
+ *
+ * Seeded by PageUiComponent.loadPage() from saved page data, then kept
+ * up to date by BindingsComponent whenever the user adds/removes a source.
+ */
+declare class DataSourceRegistryService {
+    private _ds$;
+    readonly dataSources$: rxjs.Observable<IoxDataSource[]>;
+    setDataSources(ds: IoxDataSource[]): void;
+    getDataSources(): IoxDataSource[];
+    findByAlias(alias: string): IoxDataSource | undefined;
+    getAliasOptions(): {
+        label: string;
+        value: string;
+    }[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataSourceRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataSourceRegistryService>;
+}
+
+/**
+ * Wires ComponentNode interactions to live DOM elements via the
+ * OverlayService node-element registry.
+ *
+ * Call `attach(node)` after the node is rendered and registered.
+ * Call `detach(node)` on destroy to tear down listeners/observers.
+ */
+declare class InteractionEngineService {
+    private overlayService;
+    private attached;
+    constructor(overlayService: OverlayService);
+    /** Wire all interactions for a node to its rendered DOM element. */
+    attach(node: ComponentNode): void;
+    /** Tear down all interaction listeners for a node and reset its animated state. */
+    detach(node: ComponentNode): void;
+    /** Re-attach interactions after they have been edited in the panel. */
+    refresh(node: ComponentNode): void;
+    /**
+     * Replay all interactions on a node immediately, regardless of their trigger.
+     * Used by the builder overlay play button for in-editor animation preview.
+     * Uses fill:'none' so the element returns to its natural state after the preview.
+     */
+    replay(node: ComponentNode): void;
+    private attachInteraction;
+    private attachPageLoad;
+    private attachViewportEnter;
+    private attachClick;
+    private attachHover;
+    private runActions;
+    private resolveTarget;
+    private executeAction;
+    private reverseAction;
+    private buildAnimation;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InteractionEngineService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InteractionEngineService>;
+}
+
+interface ViewportState {
+    device: DeviceMode;
+    /** Real canvas width in CSS pixels (e.g., 1440 for desktop). */
+    width: number;
+    /** Visual scale factor (0–1+). Canvas is rendered at `width` then scaled. */
+    scale: number;
+}
+declare class ViewportService {
+    private state;
+    private stateSubject;
+    state$: rxjs.Observable<ViewportState>;
+    getState(): ViewportState;
+    getScale(): number;
+    setDevice(device: DeviceMode): void;
+    setScale(scale: number): void;
+    /**
+     * Calculate the scale that makes the canvas fit inside the available editor width.
+     * @param availableWidth The pixel width of the editor area that holds the canvas.
+     * @param padding Optional horizontal padding to subtract (default 20px each side).
+     */
+    fitToWidth(availableWidth: number, padding?: number): void;
+    /**
+     * Convert a screen-space coordinate to canvas-space (unscaled).
+     * Call this when translating pointer events into canvas-relative positions.
+     */
+    screenToCanvas(screenX: number, screenY: number, canvasRect: DOMRect): {
+        x: number;
+        y: number;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ViewportService>;
+}
+
+declare class BuilderComponent implements OnInit, AfterViewInit, OnChanges, OnDestroy {
+    private registry;
+    private overlayService;
+    private panelEventService;
+    private dragEngine;
+    private dsRegistry;
+    private viewportService;
+    private interactionEngine;
+    private cdr;
+    private appRef;
+    layout: ComponentNode[];
+    dataSources: IoxDataSource[];
+    orgId: string;
+    routeParams: any[];
+    pageName: string;
+    isSaving: boolean;
+    pageStatus: string;
+    pageSettings: PageSettings | null;
+    save: EventEmitter<void>;
+    back: EventEmitter<void>;
+    preview: EventEmitter<void>;
+    publishToggle: EventEmitter<void>;
+    pageSettingsChange: EventEmitter<PageSettings>;
+    applyAnimationToAll: EventEmitter<PageRouteAnimationSettings>;
+    saveBlock: EventEmitter<{
+        name: string;
+        node: ComponentNode;
+    }>;
+    previewCanvas?: ElementRef<HTMLElement>;
+    previewScrollRef?: ElementRef<HTMLElement>;
+    lenisContentRef?: ElementRef<HTMLElement>;
+    components: any[];
+    activePanel: string;
+    isPanelOpen: boolean;
+    panelTypes: typeof PanelTypes;
+    activeMode: BuilderMode;
+    builderModes: typeof BuilderMode;
+    activeDevice: DeviceMode;
+    activeZoom: number;
+    selectedItem: ComponentNode | null;
+    isDragging: boolean;
+    scrollThumbTop: number;
+    scrollThumbHeight: number;
+    isScrollbarVisible: boolean;
+    scrollbarTranslate: number;
+    activeSidebar: 'components' | 'tree';
+    showSaveBlockDialog: boolean;
+    saveBlockName: string;
+    private pendingBlockNode;
+    isPanning: boolean;
+    panX: number;
+    panY: number;
+    private panStartX;
+    private panStartY;
+    private panOriginX;
+    private panOriginY;
+    private hoverHideRaf;
+    private viewportSub?;
+    private lenis?;
+    private lenisRafId?;
+    private canvasRo?;
+    private canvasContentHeight;
+    handleToolbarModeChange(mode: BuilderMode): void;
+    handleToolbarDeviceChange(device: DeviceMode): void;
+    handleToolbarZoomChange(value: number | 'fit'): void;
+    /** Canvas width in CSS pixels (driven by ViewportService). */
+    get viewportWidth(): number;
+    /** Visual (scaled) canvas width — used to size the scroll container so the
+     *  scrollbar aligns with the right edge of the canvas, not the CMS shell. */
+    get viewportScaledWidth(): number;
+    /** CSS transform for the visual canvas.
+     *  Includes translateX(-50%) for centering because iox-page-component is
+     *  position:absolute; left:50% inside .preview-lenis-content. */
+    get viewportTransform(): string;
+    /**
+     * Height of the Lenis content proxy div (realContentHeight × scale).
+     * Lenis scrolls against this value so scroll range is always in visual px,
+     * not unscaled CSS px — correct at any zoom level.
+     */
+    get scaledContentHeight(): number;
+    /**
+     * The canvas min-height simulates a real browser viewport.
+     * We subtract the builder header (~49px) and some padding from window.innerHeight.
+     */
+    get canvasMinHeight(): number;
+    private sub?;
+    private registrySub?;
+    constructor(registry: ComponentRegistryService, overlayService: OverlayService, panelEventService: PanelEventService, dragEngine: DragEngineService, dsRegistry: DataSourceRegistryService, viewportService: ViewportService, interactionEngine: InteractionEngineService, cdr: ChangeDetectorRef, appRef: ApplicationRef);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private initLenis;
+    private destroyLenis;
+    addComponent(name: string): void;
+    onDrop(event: IoxDropEvent): void;
+    /** Resolve the width style-trait value for a node so the cdkDrag wrapper
+     *  matches the component's actual width (prevents full-canvas-width clones). */
+    getNodeWidth(node: ComponentNode): string | undefined;
+    onModeChange(mode: BuilderMode): void;
+    onDeviceChange(device: DeviceMode): void;
+    onZoomChange(value: number | 'fit'): void;
+    onBoardMouseDown(event: MouseEvent): void;
+    onBoardMouseMove(event: MouseEvent): void;
+    onBoardMouseUp(): void;
+    private autoFitViewport;
+    selectPanel(panel: string): void;
+    handleClick(event: any): void;
+    handleMouseEnter(event: any): void;
+    handleMouseLeave(): void;
+    handleCanvasClick(): void;
+    onTreeNodeSelect(node: ComponentNode): void;
+    onTreeNodeAction(event: {
+        action: NodeAction;
+        node: ComponentNode;
+    }): void;
+    onTreeNodeMove(): void;
+    onToolbarAction(event: {
+        action: ToolbarAction;
+        entry: OverlayEntry;
+    }): void;
+    confirmSaveBlock(): void;
+    cancelSaveBlock(): void;
+    private deepCloneWithNewIds;
+    private assignNewIds;
+    private _scrollbarTimer;
+    onPageScroll(event: {
+        scrollTop: number;
+        scrollHeight: number;
+        clientHeight: number;
+        scrollPercentage?: number;
+    }): void;
+    private findNodeInTree;
+    private findParentNode;
+    private handlePanelEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BuilderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BuilderComponent, "app-builder", never, { "layout": { "alias": "layout"; "required": false; }; "dataSources": { "alias": "dataSources"; "required": false; }; "orgId": { "alias": "orgId"; "required": false; }; "routeParams": { "alias": "routeParams"; "required": false; }; "pageName": { "alias": "pageName"; "required": false; }; "isSaving": { "alias": "isSaving"; "required": false; }; "pageStatus": { "alias": "pageStatus"; "required": false; }; "pageSettings": { "alias": "pageSettings"; "required": false; }; }, { "save": "save"; "back": "back"; "preview": "preview"; "publishToggle": "publishToggle"; "pageSettingsChange": "pageSettingsChange"; "applyAnimationToAll": "applyAnimationToAll"; "saveBlock": "saveBlock"; }, never, ["[builderComponents]", "[builderPanel]"], false, never>;
+}
+
+/**
+ * StyleRegistryService — manages a single <style> tag for the builder canvas.
+ *
+ * Each builder component gets a unique CSS class `.iox-node-{id}` applied to its
+ * first inner element. onUpdate() in the style panel calls upsert() to compile
+ * the flat style-trait map into a CSS rule and flush it to the stylesheet.
+ *
+ * This replaces the old [ngStyle] binding, enabling future support for
+ * hover states, breakpoints, and pseudo-selectors without DOM modifications.
+ *
+ * Scoped to PageUiComponent.providers[] — one stylesheet per builder instance.
+ */
+declare class StyleRegistryService {
+    private rules;
+    private styleEl;
+    init(): void;
+    upsert(nodeId: string, styles: Record<string, any>): void;
+    remove(nodeId: string): void;
+    destroy(): void;
+    private compile;
+    private toKebabCase;
+    private flush;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StyleRegistryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StyleRegistryService>;
+}
+
+/**
+ * RenderDirective — applied to <ng-container> to dynamically instantiate a
+ * builder component with zero wrapper elements in the DOM.
+ *
+ * A directive's ViewContainerRef inserts the created component's host element as
+ * a sibling of the ng-container comment node — directly inside the parent element
+ * — so the resulting DOM has no extra <app-renderer> wrapper.
+ *
+ * Usage:
+ *   <ng-container [ioxRender]="node"
+ *                 (onClick)="handleClick($event)"
+ *                 (onMouseEnter)="handleMouseEnter($event)"
+ *                 (onMouseLeave)="handleMouseLeave()">
+ *   </ng-container>
+ */
+declare class RenderDirective implements OnInit, OnDestroy {
+    private vcr;
+    private injector;
+    private registryService;
+    private overlayService;
+    private styleRegistry;
+    private interactionEngine;
+    private cdr;
+    private panelEventService;
+    ioxRender: ComponentNode | null;
+    onClick: EventEmitter<any>;
+    onMouseEnter: EventEmitter<any>;
+    onMouseLeave: EventEmitter<any>;
+    private childSubs;
+    constructor(vcr: ViewContainerRef, injector: Injector, registryService: ComponentRegistryService, overlayService: OverlayService, styleRegistry: StyleRegistryService, interactionEngine: InteractionEngineService, cdr: ChangeDetectorRef, panelEventService: PanelEventService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Walk up from `target` to find a registered parent component element.
+     * Returns { element, node } if found, or null if the target is outside
+     * all known builder components (e.g. the canvas background).
+     */
+    private findParentNodeElement;
+    private render;
+    /** Try setInput(); fall back to direct assignment for non-@Input properties. */
+    private safeSetInput;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RenderDirective, "[ioxRender]", never, { "ioxRender": { "alias": "ioxRender"; "required": false; }; }, { "onClick": "onClick"; "onMouseEnter": "onMouseEnter"; "onMouseLeave": "onMouseLeave"; }, never, never, false, never>;
+}
+
+declare class IoxDraggableDirective implements OnInit, OnDestroy {
+    private el;
+    private dragEngine;
+    /** The node (for canvas items) or component type string (for sidebar items). */
+    ioxDragData: ComponentNode | string;
+    /** Drop-zone id the item lives in. Null for sidebar items. */
+    ioxDragSourceId: string | null;
+    constructor(el: ElementRef<HTMLElement>, dragEngine: DragEngineService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IoxDraggableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IoxDraggableDirective, "[ioxDraggable]", never, { "ioxDragData": { "alias": "ioxDragData"; "required": false; }; "ioxDragSourceId": { "alias": "ioxDragSourceId"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class IoxDropzoneDirective implements OnInit, OnDestroy {
+    private el;
+    private dragEngine;
+    private cdr;
+    ioxDropzoneId: string;
+    ioxDropzoneData: ComponentNode[];
+    /** Optional callback invoked after a drop lands in this zone (e.g. repeater preview refresh). */
+    ioxDropzonePostDrop?: () => void;
+    ioxDrop: EventEmitter<IoxDropEvent>;
+    constructor(el: ElementRef<HTMLElement>, dragEngine: DragEngineService, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IoxDropzoneDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IoxDropzoneDirective, "[ioxDropzone]", never, { "ioxDropzoneId": { "alias": "ioxDropzoneId"; "required": false; }; "ioxDropzoneData": { "alias": "ioxDropzoneData"; "required": false; }; "ioxDropzonePostDrop": { "alias": "ioxDropzonePostDrop"; "required": false; }; }, { "ioxDrop": "ioxDrop"; }, never, never, false, never>;
+}
+
+declare class OverlayComponent implements OnInit, OnDestroy {
+    private overlayService;
+    private viewportService;
+    private cdr;
+    toolbarAction: EventEmitter<{
+        action: ToolbarAction;
+        entry: OverlayEntry;
+    }>;
+    hoverEntry: OverlayEntry | null;
+    selectEntry: OverlayEntry | null;
+    hiOutlineStyle: Record<string, string>;
+    hiMarginStyle: Record<string, string>;
+    hiPaddingStyle: Record<string, string>;
+    selectOutlineStyle: Record<string, string>;
+    moreMenuVisible: boolean;
+    contextMenuVisible: boolean;
+    contextMenuStyle: Record<string, string>;
+    private subs;
+    private resizeObserver?;
+    private containerResizeObserver?;
+    private mutationObserver?;
+    private boundUpdate;
+    private activeScrollContainer;
+    constructor(overlayService: OverlayService, viewportService: ViewportService, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onSelectParent(event: MouseEvent): void;
+    onDuplicate(event: MouseEvent): void;
+    onDelete(event: MouseEvent): void;
+    onPlay(event: MouseEvent): void;
+    onSaveAsBlock(event: MouseEvent): void;
+    onToggleMore(event: MouseEvent): void;
+    closeMoreMenu(): void;
+    onContextMenu(event: MouseEvent): void;
+    onContextSaveAsBlock(event: MouseEvent): void;
+    closeContextMenu(): void;
+    get hasInteractions(): boolean;
+    private observeSelectElement;
+    private updateAll;
+    private updateHover;
+    private updateSelect;
+    /** Build position/size styles for a position:fixed overlay box. */
+    private createBoxStyle;
+    private createRingClipPath;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OverlayComponent, "app-overlay", never, {}, { "toolbarAction": "toolbarAction"; }, never, never, false, never>;
+}
+
+declare class ToolbarComponent {
+    activeMode: BuilderMode;
+    activeDevice: DeviceMode;
+    activeZoom: number;
+    canUndo: boolean;
+    canRedo: boolean;
+    isSaving: boolean;
+    pageStatus: string;
+    modeChange: EventEmitter<BuilderMode>;
+    deviceChange: EventEmitter<DeviceMode>;
+    zoomChange: EventEmitter<number | "fit">;
+    undo: EventEmitter<void>;
+    redo: EventEmitter<void>;
+    save: EventEmitter<void>;
+    preview: EventEmitter<void>;
+    publishToggle: EventEmitter<void>;
+    get isPublished(): boolean;
+    modePopover: Popover;
+    devicePopover: Popover;
+    zoomPopover: Popover;
+    modes: typeof BuilderMode;
+    deviceOptions: DeviceOption[];
+    zoomOptions: ZoomOption[];
+    get activeModeIcon(): string;
+    get activeModeLabel(): string;
+    get activeDeviceOption(): DeviceOption;
+    get zoomLabel(): string;
+    toggleModePopover(event: Event): void;
+    selectMode(mode: BuilderMode): void;
+    toggleDevicePopover(event: Event): void;
+    selectDevice(mode: DeviceMode): void;
+    toggleZoomPopover(event: Event): void;
+    selectZoom(value: number | 'fit'): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ToolbarComponent, "app-toolbar", never, { "activeMode": { "alias": "activeMode"; "required": false; }; "activeDevice": { "alias": "activeDevice"; "required": false; }; "activeZoom": { "alias": "activeZoom"; "required": false; }; "canUndo": { "alias": "canUndo"; "required": false; }; "canRedo": { "alias": "canRedo"; "required": false; }; "isSaving": { "alias": "isSaving"; "required": false; }; "pageStatus": { "alias": "pageStatus"; "required": false; }; }, { "modeChange": "modeChange"; "deviceChange": "deviceChange"; "zoomChange": "zoomChange"; "undo": "undo"; "redo": "redo"; "save": "save"; "preview": "preview"; "publishToggle": "publishToggle"; }, never, never, false, never>;
+}
+
+declare class SectionComponent implements OnInit, OnDestroy {
+    private dragEngine;
+    private cdr;
+    children: ComponentNode[];
+    style: {
+        [key: string]: any;
+    };
+    nodeId: string;
+    dropListId: string;
+    childClick: EventEmitter<any>;
+    childMouseEnter: EventEmitter<any>;
+    childMouseLeave: EventEmitter<void>;
+    constructor(dragEngine: DragEngineService, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    get listOrientation(): 'horizontal' | 'vertical';
+    getChildWidth(node: ComponentNode): string | undefined;
+    ngOnDestroy(): void;
+    onDrop(event: IoxDropEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SectionComponent, "app-section", never, { "children": { "alias": "children"; "required": false; }; "style": { "alias": "style"; "required": false; }; "nodeId": { "alias": "nodeId"; "required": false; }; "dropListId": { "alias": "dropListId"; "required": false; }; }, { "childClick": "childClick"; "childMouseEnter": "childMouseEnter"; "childMouseLeave": "childMouseLeave"; }, never, never, false, never>;
+}
+
+declare class BuilderContainerComponent implements OnInit, OnDestroy {
+    private dragEngine;
+    private cdr;
+    children: ComponentNode[];
+    style: {
+        [key: string]: any;
+    };
+    nodeId: string;
+    dropListId: string;
+    childClick: EventEmitter<any>;
+    childMouseEnter: EventEmitter<any>;
+    childMouseLeave: EventEmitter<void>;
+    constructor(dragEngine: DragEngineService, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get listOrientation(): 'horizontal' | 'vertical';
+    getChildWidth(node: ComponentNode): string | undefined;
+    onDrop(event: IoxDropEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BuilderContainerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BuilderContainerComponent, "app-builder-container", never, { "children": { "alias": "children"; "required": false; }; "style": { "alias": "style"; "required": false; }; "nodeId": { "alias": "nodeId"; "required": false; }; "dropListId": { "alias": "dropListId"; "required": false; }; }, { "childClick": "childClick"; "childMouseEnter": "childMouseEnter"; "childMouseLeave": "childMouseLeave"; }, never, never, false, never>;
+}
+
+declare class BuilderLinkedContainerComponent implements OnInit, OnDestroy {
+    private dragEngine;
+    private cdr;
+    private elRef;
+    private isPreview;
+    children: ComponentNode[];
+    style: {
+        [key: string]: any;
+    };
+    nodeId: string;
+    dropListId: string;
+    linkType: 'external' | 'page';
+    url: string;
+    pageRoute: string;
+    target: '_self' | '_blank' | '_parent' | '_top';
+    childClick: EventEmitter<any>;
+    childMouseEnter: EventEmitter<any>;
+    childMouseLeave: EventEmitter<void>;
+    private capturePreventDefault;
+    constructor(dragEngine: DragEngineService, cdr: ChangeDetectorRef, elRef: ElementRef<HTMLElement>, isPreview: boolean);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get resolvedHref(): string;
+    get listOrientation(): 'horizontal' | 'vertical';
+    getChildWidth(node: ComponentNode): string | undefined;
+    onDrop(event: IoxDropEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BuilderLinkedContainerComponent, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BuilderLinkedContainerComponent, "app-builder-linked-container", never, { "children": { "alias": "children"; "required": false; }; "style": { "alias": "style"; "required": false; }; "nodeId": { "alias": "nodeId"; "required": false; }; "dropListId": { "alias": "dropListId"; "required": false; }; "linkType": { "alias": "linkType"; "required": false; }; "url": { "alias": "url"; "required": false; }; "pageRoute": { "alias": "pageRoute"; "required": false; }; "target": { "alias": "target"; "required": false; }; }, { "childClick": "childClick"; "childMouseEnter": "childMouseEnter"; "childMouseLeave": "childMouseLeave"; }, never, never, false, never>;
+}
+
+/** Optional CMS content fetcher. Provide from the host app to enable Repeater data preview. */
+declare const IOX_CONTENT_SERVICE: InjectionToken<IoxContentService>;
+/** Optional font manager. Provide from the host app to populate the fontFamily dropdown. */
+declare const IOX_FONT_MANAGER: InjectionToken<IoxFontManager>;
+interface IoxContentService {
+    getContent(contentType: string, orgId?: string): rxjs.Observable<any>;
+}
+interface IoxFontManager {
+    loadFonts(orgId: string): void;
+    uploadedFonts$: rxjs.Observable<any>;
+    getAllFontOptions(): {
+        label: string;
+        value: string;
+    }[];
+}
+
+declare class BuilderRepeaterComponent implements OnInit, OnDestroy {
+    private dragEngine;
+    private overlayService;
+    private contentService;
+    private dsRegistry;
+    private panelEventService;
+    private activatedRoute;
+    private cdr;
+    children: ComponentNode[];
+    style: {
+        [key: string]: any;
+    };
+    nodeId: string;
+    dropListId: string;
+    childClick: EventEmitter<any>;
+    childMouseEnter: EventEmitter<any>;
+    childMouseLeave: EventEmitter<void>;
+    items: any[];
+    previewRows: ComponentNode[][];
+    isLoading: boolean;
+    /** Bound reference passed to [ioxDropzonePostDrop] so the directive can call it. */
+    readonly refreshPreviewsBound: () => void;
+    private _source;
+    private _limit;
+    private orgId;
+    private bindingSub?;
+    get source(): string;
+    set source(value: string);
+    get limit(): number;
+    set limit(value: number);
+    constructor(dragEngine: DragEngineService, overlayService: OverlayService, contentService: IoxContentService | null, dsRegistry: DataSourceRegistryService, panelEventService: PanelEventService, activatedRoute: ActivatedRoute, cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onDrop(event: IoxDropEvent): void;
+    private fetchData;
+    private refreshPreviews;
+    private applyFirstItemToTemplate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BuilderRepeaterComponent, [null, null, { optional: true; }, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BuilderRepeaterComponent, "app-builder-repeater", never, { "children": { "alias": "children"; "required": false; }; "style": { "alias": "style"; "required": false; }; "nodeId": { "alias": "nodeId"; "required": false; }; "dropListId": { "alias": "dropListId"; "required": false; }; "source": { "alias": "source"; "required": false; }; "limit": { "alias": "limit"; "required": false; }; }, { "childClick": "childClick"; "childMouseEnter": "childMouseEnter"; "childMouseLeave": "childMouseLeave"; }, never, never, false, never>;
+}
+
+declare class PanelChildComponent {
+    name: string;
+    template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PanelChildComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PanelChildComponent, "panel-child", never, { "name": { "alias": "name"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class PanelComponent implements AfterContentInit, OnDestroy {
+    private panelEventService;
+    isPanelOpen: boolean;
+    activePanel: string | null;
+    panelChildren: QueryList<PanelChildComponent>;
+    private sub?;
+    constructor(panelEventService: PanelEventService);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PanelComponent, "app-panel", never, {}, {}, ["panelChildren"], never, false, never>;
+}
+
+interface TreeNode {
+    node: ComponentNode;
+    icon: string;
+    label: string;
+    depth: number;
+    expanded: boolean;
+    hasChildren: boolean;
+    /** Reference to the parent's children array that contains this node. */
+    parentArray: ComponentNode[];
+    /** Index of this node inside parentArray. */
+    indexInParent: number;
+}
+declare class LayerTreeComponent implements OnInit, OnDestroy {
+    private registry;
+    private overlayService;
+    layout: ComponentNode[];
+    nodeSelect: EventEmitter<ComponentNode>;
+    nodeAction: EventEmitter<{
+        action: NodeAction;
+        node: ComponentNode;
+    }>;
+    nodeMove: EventEmitter<void>;
+    flatTree: TreeNode[];
+    selectedNodeId: string | null;
+    hoveredNodeId: string | null;
+    /** Cache: component type → icon class */
+    private iconMap;
+    private selectSub?;
+    /** Last-seen structural signature — used by ngDoCheck to skip no-op rebuilds. */
+    private _layoutSig;
+    constructor(registry: ComponentRegistryService, overlayService: OverlayService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngDoCheck(): void;
+    /** Cheap structural signature: node IDs + nesting depth only. */
+    private sig;
+    onNodeClick(treeNode: TreeNode): void;
+    onNodeMouseEnter(treeNode: TreeNode): void;
+    onNodeMouseLeave(): void;
+    toggleExpand(treeNode: TreeNode, event: MouseEvent): void;
+    onDeleteNode(treeNode: TreeNode, event: MouseEvent): void;
+    onDuplicateNode(treeNode: TreeNode, event: MouseEvent): void;
+    /**
+     * CDK drop handler for tree reorder.
+     * Works on the flat tree indices — maps back to parent arrays to do the move.
+     */
+    onTreeDrop(event: CdkDragDrop<TreeNode[]>): void;
+    /** Build a type→icon lookup from the registry so we don't instantiate configs per node. */
+    private buildIconMap;
+    private expandedState;
+    private rebuild;
+    private flattenTree;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayerTreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayerTreeComponent, "app-layer-tree", never, { "layout": { "alias": "layout"; "required": false; }; }, { "nodeSelect": "nodeSelect"; "nodeAction": "nodeAction"; "nodeMove": "nodeMove"; }, never, never, false, never>;
+}
+
+declare class InteractionsPanelComponent implements OnInit, OnDestroy {
+    private overlayService;
+    node: ComponentNode | null;
+    triggerOptions: {
+        value: InteractionTrigger;
+        label: string;
+        icon: string;
+    }[];
+    actionTypeOptions: {
+        value: InteractionActionType;
+        label: string;
+    }[];
+    easingOptions: string[];
+    interactions: IoxInteraction[];
+    /** State for the "add interaction" form */
+    isAdding: boolean;
+    newTrigger: InteractionTrigger;
+    newActionType: InteractionActionType;
+    newDuration: number;
+    newDelay: number;
+    newEasing: string;
+    newOnce: boolean;
+    /** Expanded interaction ID for editing */
+    expandedId: string | null;
+    private selectSub?;
+    constructor(overlayService: OverlayService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getTriggerLabel(trigger: InteractionTrigger): string;
+    getTriggerIcon(trigger: InteractionTrigger): string;
+    getActionLabel(type: InteractionActionType): string;
+    getActionsSummary(interaction: IoxInteraction): string;
+    toggleExpand(id: string): void;
+    startAdd(): void;
+    cancelAdd(): void;
+    confirmAdd(): void;
+    removeInteraction(id: string): void;
+    addAction(interaction: IoxInteraction): void;
+    removeAction(interaction: IoxInteraction, index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InteractionsPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InteractionsPanelComponent, "app-interactions-panel", never, { "node": { "alias": "node"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class IoxBuilderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IoxBuilderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IoxBuilderModule, [typeof BuilderComponent, typeof RenderDirective, typeof IoxDraggableDirective, typeof IoxDropzoneDirective, typeof OverlayComponent, typeof ToolbarComponent, typeof SectionComponent, typeof BuilderContainerComponent, typeof BuilderLinkedContainerComponent, typeof BuilderRepeaterComponent, typeof PanelComponent, typeof PanelChildComponent, typeof LayerTreeComponent, typeof InteractionsPanelComponent], [typeof i15.CommonModule, typeof i16.FormsModule, typeof i17.DragDropModule, typeof i18.AccordionModule, typeof i19.ButtonModule, typeof i20.PopoverModule, typeof i21.InputTextModule, typeof i22.SelectModule, typeof i23.TooltipModule, typeof i24.DialogModule, typeof i25.IoxPageModule], [typeof i15.CommonModule, typeof i16.FormsModule, typeof i17.DragDropModule, typeof i18.AccordionModule, typeof i19.ButtonModule, typeof i20.PopoverModule, typeof i21.InputTextModule, typeof i22.SelectModule, typeof i23.TooltipModule, typeof i24.DialogModule, typeof i25.IoxPageModule, typeof BuilderComponent, typeof RenderDirective, typeof IoxDraggableDirective, typeof IoxDropzoneDirective, typeof OverlayComponent, typeof ToolbarComponent, typeof SectionComponent, typeof BuilderContainerComponent, typeof BuilderLinkedContainerComponent, typeof BuilderRepeaterComponent, typeof PanelComponent, typeof PanelChildComponent, typeof LayerTreeComponent, typeof InteractionsPanelComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IoxBuilderModule>;
+}
+
+declare class BuilderButtonComponentConfig extends ComponentConfig {
+    constructor();
+}
+
+declare class CardComponentConfig extends ComponentConfig {
+    constructor();
+}
+
+declare class BuilderContainerComponentConfig extends ComponentConfig {
+    constructor();
+}
+
+declare class BuilderDividerComponentConfig extends ComponentConfig {
+    constructor();
+}
+
+declare class BuilderHeadingComponentConfig extends ComponentConfig {
+    constructor();
+}
+
+declare class BuilderIconComponentConfig extends ComponentConfig {
+    constructor();
+}
+
+declare class BuilderImageComponentConfig extends ComponentConfig {
+    constructor();
+}
+
+declare class BuilderLinkComponentConfig extends ComponentConfig {
+    constructor();
+}
+
+declare class BuilderLinkedContainerConfig extends ComponentConfig {
+    constructor();
+}
+
+declare class RepeaterComponentConfig extends ComponentConfig {
+    constructor();
+}
+
+declare class SectionComponentConfig extends ComponentConfig {
+    constructor();
+}
+
+declare class BuilderSpacerComponentConfig extends ComponentConfig {
+    constructor();
+}
+
+declare class TextBlockComponentConfig extends ComponentConfig {
+    constructor();
+}
+
+export { ACTION_TYPE_OPTIONS, BuilderButtonComponentConfig, BuilderComponent, BuilderContainerComponent, BuilderContainerComponentConfig, BuilderDividerComponentConfig, BuilderHeadingComponentConfig, BuilderIconComponentConfig, BuilderImageComponentConfig, BuilderLinkComponentConfig, BuilderLinkedContainerComponent, BuilderLinkedContainerConfig, BuilderMode, BuilderRepeaterComponent, BuilderSpacerComponentConfig, CardComponentConfig, ComponentConfig, ComponentRegistryService, DEVICE_OPTIONS, DataSourceRegistryService, DeviceMode, DragEngineService, EASING_OPTIONS, GroupStyleConfig, IOX_CONTENT_SERVICE, IOX_FONT_MANAGER, InteractionEngineService, InteractionsPanelComponent, IoxBuilderModule, IoxDraggableDirective, IoxDropzoneDirective, LayerTreeComponent, NodeAction, OverlayComponent, OverlayService, PanelChildComponent, PanelComponent, PanelEventService, PanelEventTypes, PanelTypes, ROUTE_ANIMATION_OPTIONS, RenderDirective, RepeaterComponentConfig, SectionComponent, SectionComponentConfig, StyleCategory, StyleRegistryService, TraitConfig as StyleTraitConfig, TRIGGER_OPTIONS, TextBlockComponentConfig, ToolbarAction, ToolbarComponent, TraitConfig, TraitInputType, UNITS_ALL, UNITS_DEG, UNITS_FIXED, UNITS_NO_VW, ViewportService, ZOOM_OPTIONS, defaultPageSettings, generateNodeId, resolveTraitControllerType, resolveTraitOptions };
+export type { ComponentNode, ComponentTrait, DeviceOption, DragPayload, DsFilterByQueryParam, DsFilterByRouteParam, InteractionAction, InteractionActionType, InteractionTrigger, IoxBinding, IoxContentService, IoxDataSource, IoxDropEvent, IoxFontManager, IoxInteraction, NodeRef, OverlayBoxModel, OverlayBoxSpacing, OverlayEntry, PageRouteAnimationSettings, PageScrollSettings, PageSettings, PageStyleSettings, PanelEvent, QuadSizeSegment, RouteAnimationPreset, StyleTrait, StyleTraitGroup, TraitOptionMap, TraitSelectOption, TraitShowCondition, ViewportState, ZoomOption };