@praxisui/dynamic-form 0.0.1

package/index.d.ts

@@ -0,0 +1,1104 @@
+import * as i0 from '@angular/core';
+import { OnChanges, OnDestroy, EventEmitter, SimpleChanges, OnInit, ChangeDetectorRef, Provider } from '@angular/core';
+import { FormGroup, FormBuilder } from '@angular/forms';
+import { MatDialog } from '@angular/material/dialog';
+import { MatSnackBar } from '@angular/material/snack-bar';
+import { CdkDragStart, CdkDragMove, CdkDragEnd, CdkDragDrop } from '@angular/cdk/drag-drop';
+import { ConfigStorage, FormLayout, FieldMetadata, FormLayoutRule, FormRuleContext, ValidatorOptions, FormSection, FormRow, FormColumn, FormConfig, FormActionButton, BackConfig, FormHooksLayout, EndpointConfig, FormSubmitEvent, FormReadyEvent, FormValueChangeEvent, SyncResult, FormInitializationError, FormCustomActionEvent, FormActionConfirmationEvent, GenericCrudService, ConnectionStorage, DynamicFormService, ErrorMessageService, SchemaNormalizerService, ComponentMetadataRegistry, GlobalConfigService, FormHooksRegistry, FormHookPreset, FormConfigState, FieldDefinition, ComponentDocMeta, Breakpoint, IconPickerService } from '@praxisui/core';
+import * as rxjs from 'rxjs';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { SettingsPanelService, SettingsValueProvider } from '@praxisui/settings-panel';
+import { KeyboardShortcutService } from '@praxisui/dynamic-fields';
+import { RuleBuilderConfig, RuleBuilderState } from '@praxisui/visual-builder';
+
+declare class FormLayoutService {
+    private storage?;
+    constructor(storage?: ConfigStorage | undefined);
+    loadLayout(formId: string): FormLayout | null;
+    saveLayout(formId: string, layout: FormLayout): void;
+    clearLayout(formId: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormLayoutService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormLayoutService>;
+}
+
+declare class FormContextService {
+    private fieldsByContext;
+    private componentsByContext;
+    private formRulesByContext;
+    private currentContext;
+    getCurrentContext(): string;
+    setContext(context: string): void;
+    getAvailableFields$(): Observable<FieldMetadata[]>;
+    setAvailableFields(fields: FieldMetadata[]): void;
+    registerFieldComponent(fieldName: string, component: any): void;
+    getFieldComponent(fieldName: string): any | null;
+    unregisterFieldComponent(fieldName: string): void;
+    setFormRules(rules: FormLayoutRule[]): void;
+    getFormRuleById(ruleId: string): FormLayoutRule | undefined;
+    getFormRulesByContext(ruleContext: FormRuleContext): FormLayoutRule[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormContextService>;
+}
+
+/**
+ * The result of applying a set of rules against a form's data.
+ */
+interface RuleEvaluationResult {
+    /**
+     * A map where the key is the field name and the value is a boolean
+     * indicating if the field should be visible.
+     */
+    visibility: {
+        [fieldName: string]: boolean;
+    };
+    /**
+     * A map where the key is the field name and the value is a boolean
+     * indicating if the field should be required.
+     */
+    required: {
+        [fieldName: string]: boolean;
+    };
+    /**
+     * A map where the key is the field name and the value is a boolean
+     * indicating if the field should be read-only (disabled but visible).
+     */
+    readonly?: {
+        [fieldName: string]: boolean;
+    };
+    /**
+     * Optional validator overrides computed from rules for each field.
+     */
+    metaUpdates?: {
+        [fieldName: string]: Partial<ValidatorOptions>;
+    };
+}
+declare class FormRulesService {
+    /**
+     * Evaluates a set of form rules against the current value of a FormGroup.
+     *
+     * @param formGroup The Angular FormGroup to evaluate against.
+     * @param formRules The array of rules to process.
+     * @returns A RuleEvaluationResult object containing the visibility and required states for the fields.
+     */
+    applyRules(formGroup: FormGroup, formRules: FormLayoutRule[]): RuleEvaluationResult;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormRulesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormRulesService>;
+}
+
+type CanvasElementType = 'section' | 'row' | 'column' | 'field' | 'actions';
+interface CanvasPathPart {
+    type: CanvasElementType;
+    name: string;
+    data: FormSection | FormRow | FormColumn | FieldMetadata | any;
+    domElement: HTMLElement;
+}
+interface CanvasElement {
+    type: CanvasElementType;
+    domElement: HTMLElement;
+    data: FormSection | FormRow | FormColumn | FieldMetadata | any;
+    path: CanvasPathPart[];
+}
+
+/** Service providing immutable operations over form layout configuration. */
+type RemovePolicy = 'keepEmptyContainers' | 'pruneEmptyContainers';
+interface Operation {
+    type: string;
+    correlationId?: string;
+    origin?: string;
+    from?: {
+        sectionId?: string;
+        rowId?: string;
+        columnId?: string;
+        fieldName?: string;
+        sectionIndex?: number;
+        rowIndex?: number;
+        colIndex?: number;
+        fieldIndex?: number;
+    };
+    to?: {
+        sectionId?: string;
+        rowId?: string;
+        columnId?: string;
+        fieldName?: string;
+        sectionIndex?: number;
+        rowIndex?: number;
+        colIndex?: number;
+        fieldIndex?: number;
+        toIndex?: number;
+        toFieldIndex?: number;
+    };
+    policy?: RemovePolicy;
+    meta?: any;
+    [key: string]: any;
+}
+interface LayoutResult {
+    config: FormConfig;
+    op: Operation;
+}
+interface LayoutChange {
+    timestamp: number;
+    op: Operation;
+    config: FormConfig;
+}
+interface Path {
+    sectionIndex: number;
+    rowIndex?: number;
+    colIndex?: number;
+}
+interface PathWithIndex extends Path {
+    toIndex: number;
+}
+interface FieldPath extends Path {
+    colIndex: number;
+    fieldIndex: number;
+}
+interface FieldPathWithIndex extends Path {
+    colIndex: number;
+    toFieldIndex: number;
+}
+interface FieldPathContainer extends Path {
+    colIndex: number;
+}
+interface IdPath {
+    sectionId: string;
+    rowId?: string;
+    columnId?: string;
+    fieldName?: string;
+}
+interface ValidationReport {
+    valid: boolean;
+    errors: string[];
+}
+declare class DynamicFormLayoutService {
+    private readonly changesSubject;
+    readonly changes$: rxjs.Observable<LayoutChange>;
+    private emit;
+    normalizeConfig(config: FormConfig): FormConfig;
+    validateConfig(config: FormConfig): ValidationReport;
+    generateFormConfigFromMetadata(fields: FieldMetadata[], options?: {
+        fieldsPerRow?: number;
+        defaultSectionTitle?: string;
+    }): FormConfig;
+    getElementPath(config: FormConfig, element: HTMLElement): CanvasPathPart[];
+    updateElement(config: FormConfig, path: CanvasPathPart[], updatedData: any, options?: {
+        correlationId?: string;
+        origin?: string;
+    }): LayoutResult;
+    private resolvePath;
+    resolvePathByIds(config: FormConfig, ids: IdPath): FieldPath;
+    private createRowsFromFields;
+    private genId;
+    private capitalizeFirstLetter;
+    private assertIndex;
+    private mutate;
+    moveSection(config: FormConfig, fromIndex: number, toIndex: number): LayoutResult;
+    insertSection(config: FormConfig, section: any, atIndex?: number): LayoutResult;
+    removeSection(config: FormConfig, index: number, _policy?: RemovePolicy): LayoutResult;
+    moveRow(config: FormConfig, from: Path, to: PathWithIndex): LayoutResult;
+    insertRow(config: FormConfig, sectionIndex: number, row: any, atIndex?: number): LayoutResult;
+    removeRow(config: FormConfig, sectionIndex: number, rowIndex: number, policy?: RemovePolicy): LayoutResult;
+    moveColumn(config: FormConfig, from: Path, to: PathWithIndex): LayoutResult;
+    insertColumn(config: FormConfig, secIdx: number, rowIdx: number, col: any, atIndex?: number): LayoutResult;
+    removeColumn(config: FormConfig, secIdx: number, rowIdx: number, colIdx: number, policy?: RemovePolicy): LayoutResult;
+    moveField(config: FormConfig, from: FieldPath, to: FieldPathWithIndex, options?: {
+        policy?: RemovePolicy;
+        correlationId?: string;
+        origin?: string;
+    }): LayoutResult;
+    insertField(config: FormConfig, target: FieldPathContainer, field: any, atIdx?: number): LayoutResult;
+    removeField(config: FormConfig, secIdx: number, rowIdx: number, colIdx: number, fieldIndex: number, options?: {
+        policy?: RemovePolicy;
+        correlationId?: string;
+        origin?: string;
+    }): LayoutResult;
+    moveSectionById(config: FormConfig, sectionId: string, toIndex: number, options?: {
+        correlationId?: string;
+        origin?: string;
+    }): LayoutResult;
+    removeSectionById(config: FormConfig, sectionId: string, policy?: RemovePolicy): LayoutResult;
+    moveRowById(config: FormConfig, sectionId: string, rowId: string, toSectionId: string, toIndex: number, options?: {
+        correlationId?: string;
+        origin?: string;
+    }): LayoutResult;
+    insertRowById(config: FormConfig, sectionId: string, row: FormRow, atIndex?: number): LayoutResult;
+    removeRowById(config: FormConfig, sectionId: string, rowId: string, policy?: RemovePolicy): LayoutResult;
+    moveColumnById(config: FormConfig, sectionId: string, rowId: string, columnId: string, toSectionId: string, toRowId: string, toIndex: number, options?: {
+        correlationId?: string;
+        origin?: string;
+    }): LayoutResult;
+    insertColumnById(config: FormConfig, sectionId: string, rowId: string, column: FormColumn, atIndex?: number): LayoutResult;
+    removeColumnById(config: FormConfig, sectionId: string, rowId: string, columnId: string, policy?: RemovePolicy): LayoutResult;
+    moveFieldById(config: FormConfig, from: {
+        sectionId: string;
+        rowId: string;
+        columnId: string;
+        fieldName: string;
+    }, to: {
+        sectionId: string;
+        rowId: string;
+        columnId: string;
+        toIndex: number;
+    }, options?: {
+        policy?: RemovePolicy;
+        correlationId?: string;
+        origin?: string;
+    }): LayoutResult;
+    insertFieldById(config: FormConfig, target: {
+        sectionId: string;
+        rowId: string;
+        columnId: string;
+    }, field: any, atIndex?: number): LayoutResult;
+    removeFieldById(config: FormConfig, sectionId: string, rowId: string, columnId: string, fieldName: string, options?: {
+        policy?: RemovePolicy;
+        correlationId?: string;
+        origin?: string;
+    }): LayoutResult;
+    /**
+     * Removes empty columns, rows and sections from the provided configuration.
+     * Useful when persisting a layout with `removeEmptyContainersOnSave` enabled.
+     */
+    pruneEmptyContainers(config: FormConfig): LayoutResult;
+    addRowToSectionById(config: FormConfig, sectionId: string): LayoutResult & {
+        addedRowId: string;
+    };
+    addColumnToRowById(config: FormConfig, sectionId: string, rowId: string): LayoutResult & {
+        addedColumnId: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormLayoutService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicFormLayoutService>;
+}
+
+declare class CanvasStateService {
+    private readonly _hoveredElement$;
+    readonly hoveredElement$: rxjs.Observable<CanvasElement | null>;
+    private readonly _selectedElement$;
+    readonly selectedElement$: rxjs.Observable<CanvasElement | null>;
+    setHoveredElement(element: CanvasElement | null): void;
+    setSelectedElement(element: CanvasElement | null): void;
+    get selectedElement(): CanvasElement | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CanvasStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CanvasStateService>;
+}
+
+/**
+ * Payload emitted when a form action button is activated.
+ */
+interface PraxisFormActionEvent {
+    /** Identifier of the triggered action */
+    actionId: string;
+    /** Full button configuration for the triggered action */
+    button: FormActionButton;
+    /** Original DOM event that triggered the action */
+    originalEvent: Event;
+}
+declare class PraxisFormActionsComponent implements OnChanges, OnDestroy {
+    private shortcuts;
+    /** Configuration object describing form action buttons */
+    actions?: FormConfig['actions'];
+    /** Whether the host form is currently submitting */
+    isSubmitting: boolean;
+    /** Whether the host form is currently valid */
+    formIsValid: boolean;
+    /** Optional error message displayed above the actions */
+    submitError?: string | null;
+    /** Identifier used when registering keyboard shortcuts */
+    formId?: string;
+    /** Emitted whenever a form action button is triggered */
+    action: EventEmitter<PraxisFormActionEvent>;
+    private shortcutDisposers;
+    constructor(shortcuts: KeyboardShortcutService);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    get formActionsClasses(): {
+        [key: string]: boolean;
+    };
+    get viewClassMap(): {
+        [key: string]: boolean;
+    };
+    getMatColor(btn: FormActionButton | undefined): 'primary' | 'accent' | 'warn' | undefined;
+    getActionButtons(): FormActionButton[];
+    getVisibleButtons(): FormActionButton[];
+    getCollapsedButtons(): FormActionButton[];
+    onActionButtonClick(button: FormActionButton, event: Event): void;
+    private registerActionShortcuts;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisFormActionsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisFormActionsComponent, "praxis-form-actions", never, { "actions": { "alias": "actions"; "required": false; }; "isSubmitting": { "alias": "isSubmitting"; "required": false; }; "formIsValid": { "alias": "formIsValid"; "required": false; }; "submitError": { "alias": "submitError"; "required": false; }; "formId": { "alias": "formId"; "required": false; }; }, { "action": "action"; }, never, never, true, never>;
+}
+
+declare class PraxisDynamicForm implements OnInit, OnChanges, OnDestroy {
+    private crud;
+    private fb;
+    private cdr;
+    private layoutService;
+    private contextService;
+    private rulesService;
+    private settingsPanel;
+    private dialog;
+    private configStorage;
+    private connectionStorage;
+    private dynamicForm;
+    private snackBar;
+    private canvasState;
+    private dynamicLayout;
+    private errorMessages;
+    private schemaNormalizer;
+    private componentMetaRegistry;
+    private global;
+    private hooksRegistry?;
+    private hookPresets?;
+    private readonly DEBUG;
+    resourcePath?: string;
+    resourceId?: string | number;
+    mode: 'create' | 'edit' | 'view';
+    config: FormConfig;
+    /**
+     * Fonte de schema para construir o formulário.
+     * 'resource' (padrão) usa o schema do recurso (/{resource}/schemas -> .../all response)
+     * 'filter' usa o schema do DTO de filtro (via /schemas/filtered no POST /filter request)
+     */
+    schemaSource: 'resource' | 'filter';
+    /**
+     * CUSTOMIZAÇÃO DE LAYOUT - NÃO confundir com edição de dados do formulário
+     *
+     * Este flag controla se o usuário pode customizar a ESTRUTURA do formulário:
+     * - Mover sections, rows, columns
+     * - Configurar layout e aparência
+     * - Acessar editor de configuração
+     *
+     * É INDEPENDENTE do mode (view/edit/create) que controla os DADOS do registro
+     *
+     * @example
+     * // Formulário em modo VIEW de dados + customização HABILITADA
+     * <praxis-dynamic-form mode="view" [editModeEnabled]="true">
+     *
+     * // Formulário em modo EDIT de dados + customização DESABILITADA
+     * <praxis-dynamic-form mode="edit" [editModeEnabled]="false">
+     */
+    editModeEnabled: boolean;
+    /** Identifier for persisting layouts */
+    formId?: string;
+    /** Optional layout to use instead of generated one */
+    layout?: FormLayout;
+    /** Optional navigation back config (from CRUD host) */
+    backConfig?: BackConfig;
+    /** Optional direct hooks declaration for testing/demo (overrides config.hooks) */
+    hooks?: FormHooksLayout;
+    /** Remove empty sections/rows/columns when saving configuration */
+    removeEmptyContainersOnSave: boolean;
+    /** Enable reactive afterValidate on valueChanges (overrides config.behavior) */
+    reactiveValidation: boolean | null;
+    /** Debounce for reactive afterValidate in ms (overrides config.behavior) */
+    reactiveValidationDebounceMs: number | null;
+    /** Controls outdated schema notifications visibility and channel (only effective in edit mode) */
+    notifyIfOutdated: 'inline' | 'snackbar' | 'both' | 'none';
+    /** Snooze duration for schema outdated notifications (ms), only in edit mode */
+    snoozeMs: number;
+    /** Auto open settings when schema is detected as outdated (only in edit mode) */
+    autoOpenSettingsOnOutdated: boolean;
+    readonlyModeGlobal: boolean | null;
+    disabledModeGlobal: boolean | null;
+    presentationModeGlobal: boolean | null;
+    visibleGlobal: boolean | null;
+    /** Custom endpoints for CRUD operations */
+    private _customEndpoints;
+    get customEndpoints(): EndpointConfig;
+    set customEndpoints(value: EndpointConfig);
+    formSubmit: EventEmitter<FormSubmitEvent>;
+    formCancel: EventEmitter<void>;
+    formReset: EventEmitter<void>;
+    configChange: EventEmitter<FormConfig>;
+    formReady: EventEmitter<FormReadyEvent>;
+    valueChange: EventEmitter<FormValueChangeEvent>;
+    syncCompleted: EventEmitter<SyncResult>;
+    initializationError: EventEmitter<FormInitializationError>;
+    editModeEnabledChange: EventEmitter<boolean>;
+    customAction: EventEmitter<FormCustomActionEvent>;
+    actionConfirmation: EventEmitter<FormActionConfirmationEvent>;
+    /** Emits whenever schema outdated state changes (can be used by host) */
+    schemaStatusChange: EventEmitter<{
+        outdated: boolean;
+        serverHash?: string;
+        lastVerifiedAt?: string;
+        formId?: string;
+    }>;
+    isLoading: boolean;
+    submitting: boolean;
+    submitError: string | null;
+    initializationStatus: 'idle' | 'loading' | 'success' | 'error';
+    currentErrorMessage: string;
+    currentErrorDetails: any;
+    isRecoverable: boolean;
+    private isInitialized;
+    form: FormGroup;
+    fieldVisibility: {
+        [fieldName: string]: boolean;
+    };
+    private pendingEntityId;
+    private loadedEntityId;
+    private loadedEntityData;
+    private schemaCache;
+    private lastSchemaMeta?;
+    private schemaRootHooks?;
+    private destroy$;
+    private lastCorrelationId?;
+    private currentDnD?;
+    private columnFieldsCache;
+    private lastFieldPatchSig;
+    private lastFieldPatchAt;
+    schemaOutdated: boolean;
+    private resolvedPrefs;
+    private reactiveValidate$?;
+    openQuickConnect(): void;
+    private get debugDnD();
+    get sectionDropListIds(): string[];
+    get rowDropListIds(): string[];
+    get columnDropListIds(): string[];
+    private formHost?;
+    private fieldLoaders?;
+    private _activeSnack?;
+    presentationVars: {
+        labelPosition: 'above' | 'left';
+        labelSize: string;
+        valueSize: string;
+        compact: boolean;
+        density: 'comfortable' | 'cozy' | 'compact';
+        labelWidth: string;
+        labelAlign: 'start' | 'center' | 'end';
+        valueAlign: 'start' | 'center' | 'end';
+    };
+    hoveredElement: CanvasElement | null;
+    selectedElement: CanvasElement | null;
+    toolbarTransform: string;
+    constructor(crud: GenericCrudService<any>, fb: FormBuilder, cdr: ChangeDetectorRef, layoutService: FormLayoutService, contextService: FormContextService, rulesService: FormRulesService, settingsPanel: SettingsPanelService, dialog: MatDialog, configStorage: ConfigStorage, connectionStorage: ConnectionStorage, dynamicForm: DynamicFormService, snackBar: MatSnackBar, canvasState: CanvasStateService, dynamicLayout: DynamicFormLayoutService, errorMessages: ErrorMessageService, schemaNormalizer: SchemaNormalizerService, componentMetaRegistry: ComponentMetadataRegistry, global: GlobalConfigService, hooksRegistry?: FormHooksRegistry | undefined, hookPresets?: FormHookPreset[] | null | undefined);
+    private runHooks;
+    private resolveStageDeclarations;
+    private resolvePresetDeclarations;
+    get shouldShowConfigControls(): boolean;
+    private genCorrelationId;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private blurAllInputs;
+    private initializeForm;
+    private handleInitializationError;
+    private getErrorMessage;
+    private persistFormConfig;
+    private createDefaultConfig;
+    private syncWithServer;
+    private loadEntity;
+    private buildFormFromConfig;
+    private connectionKey;
+    private saveConnection;
+    disconnect(): void;
+    onToolbarRequestClose(): void;
+    private evaluateAndApplyRules;
+    getColumnFields(column: {
+        fields: string[];
+        id?: string;
+    }): FieldMetadata[];
+    getColumnClasses(column: FormColumn): string[];
+    private getColumnSpanClasses;
+    private getColumnOffsetClasses;
+    private getColumnOrderClasses;
+    private getColumnHiddenClasses;
+    isColumnVisible(column: FormColumn): boolean;
+    private _getConfirmationMessage;
+    private _showConfirmationDialog;
+    onFormAction(event: PraxisFormActionEvent): void;
+    private _executeAction;
+    onSubmit(): Promise<void>;
+    /**
+     * TOGGLE DE CUSTOMIZAÇÃO DE LAYOUT - NÃO É EDIÇÃO DE DADOS
+     *
+     * Este método alterna entre:
+     * - Modo normal: Usuário interage com dados do formulário (conforme mode: view/edit/create)
+     * - Modo customização: Usuário pode mover sections/rows/columns e configurar layout
+     *
+     * IMPORTANTE: Independe completamente do mode do formulário
+     */
+    toggleEditMode(): void;
+    openConfigEditor(): void;
+    onElementMouseEnter(event: MouseEvent, type: CanvasElementType, data: any, element?: HTMLElement): void;
+    onElementMouseLeave(event: MouseEvent): void;
+    onElementClick(event: MouseEvent, type: CanvasElementType, data: any, element?: HTMLElement): void;
+    /**
+     * Opens the appropriate editor based on current selection (section/row/column/field).
+     */
+    openSelectedElementEditor(): void;
+    onIgnoreOutdated(): void;
+    onSnoozeOutdated(): void;
+    private getSchemaMetaKey;
+    private getPrefsKey;
+    private getOutdatedIgnoreKey;
+    private getOutdatedSnoozeKey;
+    private getOutdatedNotifiedKey;
+    private isOutdatedIgnored;
+    private getOutdatedSnoozeUntil;
+    private setOutdatedSnooze;
+    private setOutdatedIgnore;
+    private setOutdatedNotified;
+    private wasOutdatedNotified;
+    private resolveSchemaPrefs;
+    shouldShowOutdatedInline(): boolean;
+    private maybeShowOutdatedSnack;
+    private verifyServerSchemaVersion;
+    /**
+     * Opens the Field Metadata Editor from the canvas toolbar when a field is selected.
+     * Currently a safe stub until @praxisui/metadata-editor is available.
+     */
+    openFieldMetadataEditor(): void;
+    /**
+     * Internal seam to open the metadata editor and wire up apply/save handlers.
+     * Extracted for easier testing and to avoid coupling tests to dynamic import.
+     */
+    private openFieldMetadataEditorInternal;
+    private openRowEditor;
+    private openColumnEditor;
+    private openSectionEditor;
+    private getControlTypeIcon;
+    /**
+     * Friendly control type name resolved from ComponentMetadataRegistry when available.
+     * Falls back to a local map only when there is no registered metadata.
+     */
+    private getControlTypeName;
+    /**
+     * Applies a metadata patch to the field with the given name and rebuilds the form.
+     */
+    private applyFieldMetadataPatch;
+    /** Find the DynamicFieldLoaderDirective instance that currently hosts a given field */
+    private findLoaderForField;
+    onToolbarMove(direction: 'up' | 'down'): void;
+    onToolbarToggleReadonly(): void;
+    onToolbarToggleRequired(): void;
+    onToolbarToggleHidden(): void;
+    onToolbarToggleDisabled(): void;
+    /** Helper to update metadata of the currently selected field and refresh the control if needed */
+    private updateSelectedFieldMeta;
+    onFieldMouseEnter(payload: {
+        field: FieldMetadata;
+        element: HTMLElement;
+    }): void;
+    onFieldMouseLeave(payload: {
+        field: FieldMetadata;
+        element: HTMLElement;
+    }): void;
+    onFieldClick(payload: {
+        field: FieldMetadata;
+        element: HTMLElement;
+    }): void;
+    onDragStarted(event: {
+        field: FieldMetadata;
+        index: number;
+        dragEvent: CdkDragStart<any>;
+        dragData: any;
+    }): void;
+    onDragMoved(event: {
+        field: FieldMetadata;
+        index: number;
+        dragEvent: CdkDragMove<any>;
+        dragData: any;
+    }): void;
+    onDragEnded(event: {
+        field: FieldMetadata;
+        index: number;
+        dragEvent: CdkDragEnd<any>;
+        dragData: any;
+    }): void;
+    onSectionDrop(event: CdkDragDrop<any>): void;
+    onRowDrop(event: CdkDragDrop<any>): void;
+    onColumnDrop(event: CdkDragDrop<any>): void;
+    onFieldDrop(event: CdkDragDrop<any>): void;
+    onSelectPath(pathPart: CanvasPathPart): void;
+    /**
+     * Creates a new section and uses the layout service to insert it
+     * at the correct position.
+     * @param sectionIndex The index of the section after which to insert the new one.
+     */
+    addNewSectionAfter(sectionIndex: number): void;
+    ngOnDestroy(): void;
+    trackBySection(index: number, section: FormSection): string;
+    trackByRow(index: number, row: FormRow): string;
+    trackByColumn(index: number, column: FormColumn): string;
+    retryInitialization(): void;
+    getErrorTitle(): string;
+    showDetailedError(): void;
+    private buildSchemaContext;
+    private getSchemaWithCache;
+    private isReactiveValidationEnabled;
+    private getReactiveValidationDebounceMs;
+    private setupReactiveValidation;
+    private debugLog;
+    private applyPresentationVars;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisDynamicForm, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisDynamicForm, "praxis-dynamic-form", never, { "resourcePath": { "alias": "resourcePath"; "required": false; }; "resourceId": { "alias": "resourceId"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "config": { "alias": "config"; "required": false; }; "schemaSource": { "alias": "schemaSource"; "required": false; }; "editModeEnabled": { "alias": "editModeEnabled"; "required": false; }; "formId": { "alias": "formId"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "backConfig": { "alias": "backConfig"; "required": false; }; "hooks": { "alias": "hooks"; "required": false; }; "removeEmptyContainersOnSave": { "alias": "removeEmptyContainersOnSave"; "required": false; }; "reactiveValidation": { "alias": "reactiveValidation"; "required": false; }; "reactiveValidationDebounceMs": { "alias": "reactiveValidationDebounceMs"; "required": false; }; "notifyIfOutdated": { "alias": "notifyIfOutdated"; "required": false; }; "snoozeMs": { "alias": "snoozeMs"; "required": false; }; "autoOpenSettingsOnOutdated": { "alias": "autoOpenSettingsOnOutdated"; "required": false; }; "readonlyModeGlobal": { "alias": "readonlyModeGlobal"; "required": false; }; "disabledModeGlobal": { "alias": "disabledModeGlobal"; "required": false; }; "presentationModeGlobal": { "alias": "presentationModeGlobal"; "required": false; }; "visibleGlobal": { "alias": "visibleGlobal"; "required": false; }; "customEndpoints": { "alias": "customEndpoints"; "required": false; }; }, { "formSubmit": "formSubmit"; "formCancel": "formCancel"; "formReset": "formReset"; "configChange": "configChange"; "formReady": "formReady"; "valueChange": "valueChange"; "syncCompleted": "syncCompleted"; "initializationError": "initializationError"; "editModeEnabledChange": "editModeEnabledChange"; "customAction": "customAction"; "actionConfirmation": "actionConfirmation"; "schemaStatusChange": "schemaStatusChange"; }, never, never, true, never>;
+}
+
+declare class FormConfigService {
+    private readonly _state$;
+    readonly state$: Observable<FormConfigState>;
+    readonly config$: Observable<FormConfig>;
+    get currentConfig(): FormConfig;
+    loadConfig(config: FormConfig): void;
+    updateConfig(configUpdate: Partial<FormConfig>): void;
+    private updateState;
+    /**
+     * Export the current configuration as a JSON string.
+     * @param pretty whether to pretty print the JSON
+     */
+    exportToJson(pretty?: boolean): string;
+    /**
+     * Load a configuration from a JSON string.
+     * Invalid JSON will emit an error on the service state.
+     */
+    importFromJson(json: string): void;
+    /**
+     * Validate a configuration returning an array of error messages.
+     */
+    validateConfig(config: FormConfig): string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormConfigService>;
+}
+
+interface JsonValidationResult {
+    isValid: boolean;
+    error?: string;
+    config?: FormConfig;
+}
+interface JsonEditorEvent {
+    type: 'apply' | 'format' | 'validation';
+    payload: JsonValidationResult;
+}
+declare class JsonConfigEditorComponent implements OnInit, OnDestroy {
+    private cdr;
+    private configService;
+    config: FormConfig | null;
+    configChange: EventEmitter<FormConfig>;
+    validationChange: EventEmitter<JsonValidationResult>;
+    editorEvent: EventEmitter<JsonEditorEvent>;
+    jsonText: string;
+    isValidJson: boolean;
+    jsonError: string;
+    private destroy$;
+    private jsonTextChanges$;
+    constructor(cdr: ChangeDetectorRef, configService: FormConfigService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onJsonTextChange(text: string): void;
+    applyJsonChanges(): void;
+    formatJson(): void;
+    updateJsonFromConfig(config: FormConfig): void;
+    /**
+     * Força atualização do JSON com a configuração atual
+     */
+    refreshJson(): void;
+    getCurrentConfig(): FormConfig | null;
+    hasChanges(): boolean;
+    private validateJson;
+    private updateValidationState;
+    insertHooksTemplate(): void;
+    enableReactiveValidation(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonConfigEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<JsonConfigEditorComponent, "form-json-config-editor", never, { "config": { "alias": "config"; "required": false; }; }, { "configChange": "configChange"; "validationChange": "validationChange"; "editorEvent": "editorEvent"; }, never, never, true, never>;
+}
+
+declare class PraxisDynamicFormConfigEditor implements SettingsValueProvider, OnInit, OnDestroy {
+    private storage;
+    private configService;
+    jsonEditor?: JsonConfigEditorComponent;
+    editedConfig: FormConfig;
+    ruleBuilderConfig: RuleBuilderConfig;
+    ruleBuilderState?: RuleBuilderState;
+    private initialConfig;
+    backConfig?: BackConfig;
+    formId?: string;
+    inputMode: 'create' | 'edit' | 'view';
+    isPresentationMode: boolean;
+    truncatePreview: boolean;
+    previewItems: {
+        label: string;
+        value: string;
+    }[];
+    presentationPrefs: {
+        labelPosition: 'above' | 'left';
+        labelFontSize?: number | null;
+        valueFontSize?: number | null;
+        compact?: boolean;
+        density?: 'comfortable' | 'cozy' | 'compact';
+        labelWidth?: number | null;
+        labelAlign?: 'start' | 'center' | 'end';
+        valueAlign?: 'start' | 'center' | 'end';
+    };
+    schemaPrefs: {
+        notifyIfOutdated: 'inline' | 'snackbar' | 'both' | 'none';
+        snoozeMs: number;
+        autoOpenSettingsOnOutdated: boolean;
+    };
+    serverMeta?: {
+        serverHash?: string;
+        lastVerifiedAt?: string;
+    };
+    isDirty$: BehaviorSubject<boolean>;
+    isValid$: BehaviorSubject<boolean>;
+    isBusy$: BehaviorSubject<boolean>;
+    constructor(storage: ConfigStorage, configService: FormConfigService, injectedData?: any);
+    ngOnInit(): void;
+    reset(): void;
+    private updateDirtyState;
+    getSettingsValue(): any;
+    onSave(): any;
+    onJsonConfigChange(newConfig: FormConfig): void;
+    onJsonValidationChange(result: JsonValidationResult): void;
+    onJsonEditorEvent(_event: JsonEditorEvent): void;
+    onConfigChange(newConfig: FormConfig): void;
+    onRulesChanged(state: RuleBuilderState): void;
+    private createRuleBuilderConfig;
+    private mapMetadataToSchema;
+    private mapDataTypeToFieldType;
+    ngOnDestroy(): void;
+    onCascadeApply(patch: Record<string, Partial<FieldDefinition>>): void;
+    private stripLegacy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisDynamicFormConfigEditor, [null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisDynamicFormConfigEditor, "praxis-dynamic-form-config-editor", never, {}, {}, never, never, true, never>;
+}
+interface FormConfigLike {
+    fieldMetadata?: FieldMetadata[];
+}
+declare function stripLegacyFieldMetadata(arr?: FieldMetadata[]): FieldMetadata[] | undefined;
+
+declare class PraxisFilterForm implements OnChanges, OnDestroy {
+    private dynamicForm;
+    config: FormConfig;
+    formId?: string;
+    resourcePath?: string;
+    mode?: string;
+    formReady: EventEmitter<{
+        formGroup: FormGroup<Record<string, any>>;
+    }>;
+    valueChange: EventEmitter<{
+        formData: Record<string, any>;
+    }>;
+    submit: EventEmitter<{
+        formData: Record<string, any>;
+    }>;
+    validityChange: EventEmitter<boolean>;
+    form: FormGroup<Record<string, any>>;
+    private valueChangesSub?;
+    private statusChangesSub?;
+    constructor(dynamicForm: DynamicFormService);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private buildForm;
+    onFormSubmit(): void;
+    getColumnFields(column: FormColumn): FieldMetadata[];
+    get hasLayout(): boolean;
+    trackBySection(i: number, section: FormSection): string;
+    trackByRow(i: number, _row: FormRow): string;
+    trackByColumn(i: number, col: FormColumn): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PraxisFilterForm, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PraxisFilterForm, "praxis-filter-form", never, { "config": { "alias": "config"; "required": true; }; "formId": { "alias": "formId"; "required": false; }; "resourcePath": { "alias": "resourcePath"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; }, { "formReady": "formReady"; "valueChange": "valueChange"; "submit": "submit"; "validityChange": "validityChange"; }, never, never, true, never>;
+}
+
+/** Tokens for theme colors used across the layout editor. */
+declare enum LayoutColorToken {
+    Surface = "--md-sys-color-surface",
+    SurfaceVariant = "--md-sys-color-surface-variant",
+    Outline = "--md-sys-color-outline",
+    Primary = "--md-sys-color-primary"
+}
+/**
+ * Persists UI preferences of the layout editor such as the fields palette state
+ * and exposes helpers to read theme tokens.
+ */
+declare class LayoutPrefsService {
+    private readonly paletteCollapsedKey;
+    /** Returns whether the fields palette is collapsed. */
+    getPaletteCollapsed(): boolean;
+    /** Persists the collapsed state of the fields palette. */
+    setPaletteCollapsed(collapsed: boolean): void;
+    /** Returns the current value for a theme color token. */
+    getColor(token: LayoutColorToken): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutPrefsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutPrefsService>;
+}
+
+interface FieldDropEvent {
+    event: CdkDragDrop<any>;
+    sectionIndex: number;
+    rowIndex: number;
+}
+/**
+ * Editor component for configuring sections, rows and fields of a dynamic form.
+ * Provides a collapsible palette of available fields.
+ */
+declare class LayoutEditorComponent implements OnInit {
+    config: FormConfig;
+    configChange: EventEmitter<FormConfig>;
+    paletteCollapsed: boolean;
+    protected readonly prefs: LayoutPrefsService;
+    protected readonly colorTokens: typeof LayoutColorToken;
+    selected: {
+        type: 'section' | 'row' | 'column' | 'field';
+        sectionIndex?: number;
+        rowIndex?: number;
+        columnIndex?: number;
+        fieldName?: string;
+    } | null;
+    bulkSectionGapBottom: number | null;
+    applyGapBottomToAll(): void;
+    ngOnInit(): void;
+    handleKeydown(event: KeyboardEvent): void;
+    /**
+     * Toggles the fields palette and persists the collapsed state.
+     */
+    togglePalette(): void;
+    /**
+     * Fields that are not yet placed in any section/column of the layout.
+     */
+    get availableFields(): FieldMetadata[];
+    get columnDropListIds(): string[];
+    getColumnId(sectionIndex: number, rowIndex: number, columnIndex: number): string;
+    private parseColumnId;
+    onSelect(sel: any): void;
+    clearSelection(): void;
+    selectSection(sectionIndex: number): void;
+    selectRow(sectionIndex: number, rowIndex: number): void;
+    selectColumn(sectionIndex: number, rowIndex: number, columnIndex: number): void;
+    dropField({ event }: FieldDropEvent): void;
+    dropSection(event: CdkDragDrop<FormSection[]>): void;
+    addSection(): void;
+    removeSection(index: number): void;
+    onSectionUpdated(index: number, updatedSection: FormSection): void;
+    private emitNewConfig;
+    onApplyStyleToAll(patch: Partial<FormSection>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LayoutEditorComponent, "praxis-layout-editor", never, { "config": { "alias": "config"; "required": false; }; }, { "configChange": "configChange"; }, never, never, true, never>;
+}
+
+declare class RowConfiguratorComponent {
+    row: FormRow;
+    fieldMetadata: FieldMetadata[];
+    sectionIndex: number;
+    rowIndex: number;
+    selected: {
+        type: 'section' | 'row' | 'column' | 'field';
+        sectionIndex?: number;
+        rowIndex?: number;
+        columnIndex?: number;
+        fieldName?: string;
+    } | null;
+    availableFieldsListId: string | null;
+    connectedDropListIds: string[];
+    rowChange: EventEmitter<FormRow>;
+    remove: EventEmitter<void>;
+    fieldDrop: EventEmitter<CdkDragDrop<any, any, any>>;
+    select: EventEmitter<any>;
+    activeDropIndex: number | null;
+    private hoverTimer;
+    getFieldByName(fieldName: string): FieldMetadata;
+    drop(event: CdkDragDrop<string[]>): void;
+    selectRow(): void;
+    selectColumn(index: number, event: MouseEvent): void;
+    selectField(fieldName: string, event: MouseEvent): void;
+    onDropEnter(index: number): void;
+    onDropExit(index: number): void;
+    isRowSelected(): boolean;
+    isColumnSelected(i: number): boolean;
+    isFieldSelected(fieldName: string): boolean;
+    connectedColumns(index: number): string[];
+    addColumn(): void;
+    removeColumn(index: number): void;
+    removeRow(): void;
+    getColumnId(index: number): string;
+    private generateId;
+    applyPreset(spansMd: number[]): void;
+    getSpanClasses(column: any): string[];
+    getSpanMd(column: any): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowConfiguratorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RowConfiguratorComponent, "praxis-row-configurator", never, { "row": { "alias": "row"; "required": false; }; "fieldMetadata": { "alias": "fieldMetadata"; "required": false; }; "sectionIndex": { "alias": "sectionIndex"; "required": false; }; "rowIndex": { "alias": "rowIndex"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "availableFieldsListId": { "alias": "availableFieldsListId"; "required": false; }; "connectedDropListIds": { "alias": "connectedDropListIds"; "required": false; }; }, { "rowChange": "rowChange"; "remove": "remove"; "fieldDrop": "fieldDrop"; "select": "select"; }, never, never, true, never>;
+}
+
+declare class FieldConfiguratorComponent {
+    private readonly registry;
+    field: FieldMetadata;
+    private readonly controlTypeMap;
+    private readonly categoryByType;
+    private readonly fallbackInfo;
+    get meta(): ComponentDocMeta | undefined;
+    get icon(): string;
+    get typeClass(): string;
+    get typeSpecificClass(): string;
+    get typeLabel(): string;
+    get tooltip(): string;
+    private readonly typeSpecificClassMap;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldConfiguratorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FieldConfiguratorComponent, "praxis-field-configurator", never, { "field": { "alias": "field"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/** Metadata for PraxisDynamicForm component */
+declare const PRAXIS_DYNAMIC_FORM_COMPONENT_METADATA: ComponentDocMeta;
+/** Provider para auto-registrar metadados do componente Dynamic Form. */
+declare function providePraxisDynamicFormMetadata(): Provider;
+
+declare function isRuleSatisfied(rule: FormLayoutRule, data: unknown): boolean;
+/**
+ * Applies all visibility rules to the provided data and
+ * returns a map of field name to visibility state.
+ */
+declare function applyVisibilityRules(rules: FormLayoutRule[], data: any): Record<string, boolean>;
+
+/**
+ * Converts a RuleBuilderState produced by the visual builder into
+ * an array of FormLayoutRule objects understood by the dynamic form.
+ */
+declare function ruleBuilderStateToFormLayoutRules(state: RuleBuilderState | null | undefined): FormLayoutRule[];
+/**
+ * Converts an array of FormLayoutRule back into a RuleBuilderState
+ * so that the visual builder can display the saved rules.
+ *
+ * The conversion handles a limited subset of rules (visibility and
+ * required/validation rules with simple field conditions).
+ */
+declare function formLayoutRulesToBuilderState(rules: FormLayoutRule[] | null | undefined): RuleBuilderState;
+
+/**
+ * Recursively converts arrays representing dates into ISO-8601 strings.
+ * Arrays are expected in the form `[year, month, day, hour?, minute?, second?, millisecond?]`.
+ * Non-date arrays and other values are returned untouched.
+ */
+declare function normalizeDateArrays(data: any): any;
+
+declare class CanvasToolbarComponent {
+    selectedElement: CanvasElement | null;
+    editMetadata: EventEmitter<void>;
+    delete: EventEmitter<void>;
+    moveUp: EventEmitter<void>;
+    moveDown: EventEmitter<void>;
+    selectPath: EventEmitter<CanvasPathPart>;
+    /** Emite quando o usuário solicita fechar a toolbar (ESC). */
+    requestClose: EventEmitter<void>;
+    toggleReadonly: EventEmitter<void>;
+    toggleRequired: EventEmitter<void>;
+    toggleHidden: EventEmitter<void>;
+    toggleDisabled: EventEmitter<void>;
+    get selectedLastType(): CanvasPathPart['type'] | null;
+    get isField(): boolean;
+    get isSection(): boolean;
+    get isColumn(): boolean;
+    get configTooltip(): string;
+    get readonlyIcon(): string;
+    get requiredIcon(): string;
+    get visibilityIcon(): string;
+    get disabledIcon(): string;
+    /** Fecha a toolbar com a tecla ESC quando o componente está visível. */
+    onGlobalKeydown(ev: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CanvasToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CanvasToolbarComponent, "praxis-canvas-toolbar", never, { "selectedElement": { "alias": "selectedElement"; "required": false; }; }, { "editMetadata": "editMetadata"; "delete": "delete"; "moveUp": "moveUp"; "moveDown": "moveDown"; "selectPath": "selectPath"; "requestClose": "requestClose"; "toggleReadonly": "toggleReadonly"; "toggleRequired": "toggleRequired"; "toggleHidden": "toggleHidden"; "toggleDisabled": "toggleDisabled"; }, never, never, true, never>;
+}
+
+interface EditableFormSection extends FormSection {
+    collapsible?: boolean;
+    collapsed?: boolean;
+    order?: number;
+    hidden?: {
+        xs?: boolean;
+        sm?: boolean;
+        md?: boolean;
+        lg?: boolean;
+        xl?: boolean;
+    };
+    className?: string;
+    testId?: string;
+}
+declare class SectionEditorComponent implements OnInit, OnDestroy, SettingsValueProvider {
+    private fb;
+    private data;
+    private iconPicker;
+    section: EditableFormSection;
+    form: FormGroup;
+    breakpoints: Breakpoint[];
+    isDirty$: BehaviorSubject<boolean>;
+    isValid$: BehaviorSubject<boolean>;
+    isBusy$: BehaviorSubject<boolean>;
+    private destroy$;
+    constructor(fb: FormBuilder, data: {
+        section: EditableFormSection;
+    }, iconPicker: IconPickerService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getSettingsValue(): any;
+    pickIcon(): Promise<void>;
+    clearIcon(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SectionEditorComponent, "praxis-section-editor", never, {}, {}, never, never, true, never>;
+}
+
+interface EditableFormRow extends FormRow {
+    order?: number;
+    gap?: number;
+    rowGap?: number;
+    wrap?: boolean;
+    hidden?: {
+        xs?: boolean;
+        sm?: boolean;
+        md?: boolean;
+        lg?: boolean;
+        xl?: boolean;
+    };
+    className?: string;
+    testId?: string;
+}
+declare class RowEditorComponent implements OnInit, OnDestroy, SettingsValueProvider {
+    private fb;
+    private data;
+    form: FormGroup;
+    breakpoints: Breakpoint[];
+    row: EditableFormRow;
+    isDirty$: BehaviorSubject<boolean>;
+    isValid$: BehaviorSubject<boolean>;
+    isBusy$: BehaviorSubject<boolean>;
+    private destroy$;
+    constructor(fb: FormBuilder, data: {
+        row: EditableFormRow;
+    });
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getSettingsValue(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RowEditorComponent, "praxis-row-editor", never, {}, {}, never, never, true, never>;
+}
+
+declare class ColumnEditorComponent implements OnInit, OnDestroy, SettingsValueProvider {
+    private fb;
+    private data;
+    form: FormGroup;
+    breakpoints: Breakpoint[];
+    column: FormColumn;
+    isDirty$: BehaviorSubject<boolean>;
+    isValid$: BehaviorSubject<boolean>;
+    isBusy$: BehaviorSubject<boolean>;
+    private destroy$;
+    private _previewTimer;
+    constructor(fb: FormBuilder, data: {
+        column: FormColumn;
+    });
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private applyChanges;
+    getSettingsValue(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnEditorComponent, "praxis-column-editor", never, {}, {}, never, never, true, never>;
+}
+
+declare class FieldEditorComponent {
+    field: FieldMetadata | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FieldEditorComponent, "praxis-field-editor", never, { "field": { "alias": "field"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ActionsEditorComponent {
+    actions: any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionsEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ActionsEditorComponent, "praxis-actions-editor", never, { "actions": { "alias": "actions"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { ActionsEditorComponent, CanvasStateService, CanvasToolbarComponent, ColumnEditorComponent, DynamicFormLayoutService, FieldConfiguratorComponent, FieldEditorComponent, FormConfigService, FormContextService, FormLayoutService, JsonConfigEditorComponent, LayoutColorToken, LayoutEditorComponent, LayoutPrefsService, PRAXIS_DYNAMIC_FORM_COMPONENT_METADATA, PraxisDynamicForm, PraxisDynamicFormConfigEditor, PraxisFilterForm, PraxisFormActionsComponent, RowConfiguratorComponent, RowEditorComponent, SectionEditorComponent, applyVisibilityRules, formLayoutRulesToBuilderState, isRuleSatisfied, normalizeDateArrays, providePraxisDynamicFormMetadata, ruleBuilderStateToFormLayoutRules, stripLegacyFieldMetadata };
+export type { CanvasElement, CanvasElementType, CanvasPathPart, FieldPath, FieldPathContainer, FieldPathWithIndex, FormConfigLike, IdPath, JsonEditorEvent, JsonValidationResult, LayoutChange, LayoutResult, Operation, Path, PathWithIndex, PraxisFormActionEvent, RemovePolicy, ValidationReport };