@digiform/builder 0.1.7 → 0.2.4

package/design-system/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Design System Adapter - Form Builder Exports
+ *
+ * This module re-exports the core design system adapter from @formbuilder/design-system
+ * (packages/shared-ui) and adds form-builder-specific config/preset utilities.
+ *
+ * Core adapter (types, RHC components, wrappers) lives in shared-ui.
+ * Config/preset layer (depends on generated catalog + property editors) stays here.
+ */
+export * from '../../../ui/src/design-system/index.ts';
+export * from './custom/index';
+export * from './rhc/config/index';
+export type { ComponentPropsConfig, CreatePropsConfigInput, PropDisabledConfig, PropEditorConfig, } from './rhc/utils/create-config';
+export { createPropsConfig } from './rhc/utils/create-config';
+export { generatePropertyEditorSchema } from './rhc/utils/generate-schema';

package/design-system/rhc/components.d.ts

@@ -0,0 +1,12 @@
+/**
+ * RHC Component Re-exports
+ *
+ * This is the ONLY file that should import directly from @rijkshuisstijl-community packages.
+ * All other parts of the application should import from @fb/design-system instead.
+ *
+ * This abstraction layer enables:
+ * - Single point of control for design system imports
+ * - Easy migration between design systems
+ * - Type-safe component sourcing
+ */
+export { Alert, Button, type ButtonProps, FormFieldCheckboxGroup, FormFieldCheckboxOption, FormFieldRadioGroup, FormFieldSelect, FormFieldTextarea, FormFieldTextInput, Heading, HeadingGroup, Paragraph, PreHeading, } from '@rijkshuisstijl-community/components-react';

package/design-system/rhc/config/alert.config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Configuration for Alert component
+ * Based on existing alertPropertySchema from components/alert.tsx
+ */
+export declare const alertConfig: import('../utils/create-config').ComponentPropsConfig;

package/design-system/rhc/config/button.config.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Configuration for Button component
+ * Based on existing buttonPropertySchema from components/button.tsx
+ *
+ * Note: Button has non-standard property structure - "text" is in component-level schema,
+ * not in properties. This config focuses on button-specific props.
+ */
+export declare const buttonConfig: import('../utils/create-config').ComponentPropsConfig;

package/design-system/rhc/config/checkbox.config.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Configuration for FormFieldCheckboxGroup component
+ */
+export declare const checkboxConfig: import('../utils/create-config').ComponentPropsConfig;

package/design-system/rhc/config/form-builder.config.d.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+declare const ComponentConfigSchema: z.ZodObject<{
+    /** Component name - must exist in generated catalog */
+    component: z.ZodEnum<[string, ...string[]]>;
+    /** Display name shown in form builder UI */
+    displayName: z.ZodString;
+    /** Props to expose in the form builder property editor */
+    exposedProps: z.ZodArray<z.ZodString, "many">;
+    /** Props that are managed internally by the form builder (not shown in editor) */
+    internalProps: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    displayName: string;
+    component: string;
+    exposedProps: string[];
+    internalProps: string[];
+}, {
+    displayName: string;
+    component: string;
+    exposedProps: string[];
+    internalProps?: string[] | undefined;
+}>;
+export declare const FormBuilderConfigSchema: z.ZodObject<{
+    /** Config version for tracking */
+    version: z.ZodString;
+    /** Components available in the form builder */
+    components: z.ZodArray<z.ZodObject<{
+        /** Component name - must exist in generated catalog */
+        component: z.ZodEnum<[string, ...string[]]>;
+        /** Display name shown in form builder UI */
+        displayName: z.ZodString;
+        /** Props to expose in the form builder property editor */
+        exposedProps: z.ZodArray<z.ZodString, "many">;
+        /** Props that are managed internally by the form builder (not shown in editor) */
+        internalProps: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        displayName: string;
+        component: string;
+        exposedProps: string[];
+        internalProps: string[];
+    }, {
+        displayName: string;
+        component: string;
+        exposedProps: string[];
+        internalProps?: string[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    components: {
+        displayName: string;
+        component: string;
+        exposedProps: string[];
+        internalProps: string[];
+    }[];
+    version: string;
+}, {
+    components: {
+        displayName: string;
+        component: string;
+        exposedProps: string[];
+        internalProps?: string[] | undefined;
+    }[];
+    version: string;
+}>;
+export type FormBuilderConfig = z.infer<typeof FormBuilderConfigSchema>;
+export type FormBuilderComponentConfig = z.infer<typeof ComponentConfigSchema>;
+/**
+ * Form builder configuration - defines which components and props
+ * are available in the form builder UI.
+ *
+ * This config cherry-picks a curated subset from the complete RHC catalog.
+ * All component and prop names are validated against the generated catalog
+ * at import time.
+ */
+declare const formBuilderConfig: FormBuilderConfig;
+export { formBuilderConfig };

package/design-system/rhc/config/heading.config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Configuration for Heading component
+ * Based on existing headingPropertySchema from components/heading.tsx
+ */
+export declare const headingConfig: import('../utils/create-config').ComponentPropsConfig;

package/design-system/rhc/config/index.d.ts

@@ -0,0 +1,9 @@
+export { alertConfig } from './alert.config';
+export { buttonConfig } from './button.config';
+export { checkboxConfig } from './checkbox.config';
+export { headingConfig } from './heading.config';
+export { paragraphConfig } from './paragraph.config';
+export { radioGroupConfig } from './radio-group.config';
+export { selectConfig } from './select.config';
+export { textInputConfig } from './text-input.config';
+export { textareaConfig } from './textarea.config';

package/design-system/rhc/config/paragraph.config.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Configuration for Paragraph component
+ * Based on existing paragraphPropertySchema from components/paragraph.tsx
+ *
+ * Note: RHC Paragraph uses "purpose" prop instead of "appearance".
+ * Purpose values: undefined (default), "lead", "intro", "notice"
+ */
+export declare const paragraphConfig: import('../utils/create-config').ComponentPropsConfig;

package/design-system/rhc/config/radio-group.config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Configuration for FormFieldRadioGroup component
+ * Based on existing radioGroup component from components/radioGroup.tsx
+ */
+export declare const radioGroupConfig: import('../utils/create-config').ComponentPropsConfig;

package/design-system/rhc/config/select.config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Configuration for FormFieldSelect component
+ * Based on existing dropdown component from components/dropdown.tsx
+ */
+export declare const selectConfig: import('../utils/create-config').ComponentPropsConfig;

package/design-system/rhc/config/text-input.config.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Configuration for FormFieldTextInput component
+ * Based on existing textInputPropertySchema from components/text.tsx
+ */
+export declare const textInputConfig: import('../utils/create-config').ComponentPropsConfig;

package/design-system/rhc/config/textarea.config.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Configuration for FormFieldTextarea component
+ */
+export declare const textareaConfig: import('../utils/create-config').ComponentPropsConfig;

package/design-system/rhc/index.d.ts

@@ -0,0 +1 @@
+export * from './components';

package/design-system/rhc/utils/create-config.d.ts

@@ -0,0 +1,76 @@
+import { ComponentConfig } from '../../../../../core/src/index.ts';
+import { PropertyFieldType } from '../../../features/property-editors/types/schema';
+import { RHC_CATALOG, RHCComponentProp } from '../../generated/rhc-catalog.generated';
+export type RHCComponentName = keyof typeof RHC_CATALOG;
+export interface SelectOption {
+    label: string;
+    value: string;
+    description?: string;
+}
+/**
+ * Configuration for an enabled property editor
+ */
+export interface PropEditorConfig {
+    enabled: true;
+    editorType: PropertyFieldType;
+    editorLabel: string;
+    tab: "general" | "validation" | "advanced" | "triggers" | "conditions" | "styling";
+    required?: boolean;
+    placeholder?: string;
+    options?: SelectOption[];
+    defaultValue?: unknown;
+    description?: string;
+    rows?: number;
+    condition?: (component: ComponentConfig) => boolean;
+}
+/**
+ * Configuration for a disabled property (internal or not exposed)
+ */
+export interface PropDisabledConfig {
+    enabled: false;
+    internal?: boolean;
+    reason: string;
+}
+/**
+ * Union of enabled and disabled prop configs
+ */
+export type PropConfig = PropEditorConfig | PropDisabledConfig;
+/**
+ * Complete configuration for a component's props
+ */
+export interface ComponentPropsConfig {
+    component: RHCComponentName;
+    props: Record<string, PropConfig>;
+    catalogProps: readonly RHCComponentProp[];
+}
+/**
+ * Input for createPropsConfig factory
+ */
+export interface CreatePropsConfigInput {
+    enabled: Record<string, Omit<PropEditorConfig, "enabled">>;
+    internal?: string[];
+}
+/**
+ * Factory function to create component props configuration with automatic prop validation
+ *
+ * @param componentName - RHC component name (validated against catalog)
+ * @param input - Configuration specifying enabled and internal props
+ * @returns Complete ComponentPropsConfig with all catalog props accounted for
+ * @throws Error if component not found in catalog or if prop names don't exist in catalog
+ *
+ * @example
+ * ```ts
+ * const config = createPropsConfig("FormFieldTextInput", {
+ *   enabled: {
+ *     label: {
+ *       editorType: "text",
+ *       editorLabel: "Label",
+ *       tab: "general",
+ *       required: true
+ *     }
+ *   },
+ *   internal: ["value", "onChange"]
+ * });
+ * ```
+ */
+export declare function createPropsConfig(componentName: RHCComponentName, input: CreatePropsConfigInput): ComponentPropsConfig;

package/design-system/rhc/utils/generate-schema.d.ts

@@ -0,0 +1,20 @@
+import { PropertyEditorSchema } from '../../../features/property-editors/types/schema';
+import { ComponentPropsConfig } from './create-config';
+/**
+ * Generates a PropertyEditorSchema from a ComponentPropsConfig
+ *
+ * This function converts the factory-based config into the schema format expected by the admin UI.
+ * It maps enabled props to PropertyFieldSchema objects and adds standard component-level editors.
+ *
+ * @param config - Component props configuration created by createPropsConfig()
+ * @returns PropertyEditorSchema compatible with existing admin property panel
+ *
+ * @example
+ * ```ts
+ * const config = createPropsConfig("FormFieldTextInput", { ... });
+ * const schema = generatePropertyEditorSchema(config);
+ * // schema.properties.label = { type: "text", label: "Label", ... }
+ * // schema.component.validation = { type: "validationRules", ... }
+ * ```
+ */
+export declare function generatePropertyEditorSchema(config: ComponentPropsConfig): PropertyEditorSchema;

package/design-system/types.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Design System Adapter Types
+ *
+ * This module defines types for the design system adapter layer that abstracts
+ * the underlying design system implementation (RHC or custom components).
+ */
+/**
+ * ComponentSource identifies the origin of a component.
+ *
+ * - 'rhc': Component from Rijkshuisstijl Community design system
+ * - 'custom': Custom-built component or preset
+ */
+export type ComponentSource = "rhc" | "custom";
+/**
+ * Adapter interface for design system components.
+ * Components from different sources (RHC, custom) implement this interface
+ * to provide a consistent API to the form builder.
+ */
+export interface DesignSystemAdapter {
+    source: ComponentSource;
+    [key: string]: unknown;
+}

package/error-boundaries/BaseErrorBoundary/BaseErrorBoundary.d.ts

@@ -0,0 +1,31 @@
+import { Component, ErrorInfo, ReactNode } from 'react';
+export interface ErrorBoundaryState {
+    hasError: boolean;
+    error: Error | null;
+    errorInfo: ErrorInfo | null;
+    errorId: string | null;
+}
+export interface ErrorBoundaryProps {
+    children: ReactNode;
+    fallbackComponent?: React.ComponentType<ErrorFallbackProps>;
+    onError?: (error: Error, errorInfo: ErrorInfo, errorId: string) => void;
+    level?: "app" | "feature" | "component";
+    context?: string;
+}
+export interface ErrorFallbackProps {
+    error: Error;
+    errorInfo: ErrorInfo;
+    resetError: () => void;
+    level: string;
+    context?: string;
+    errorId: string;
+}
+export declare class BaseErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(error: Error): Partial<ErrorBoundaryState>;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    private logErrorToService;
+    private resetError;
+    render(): string | number | boolean | Iterable<ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}
+export default BaseErrorBoundary;

package/error-boundaries/ComponentErrorBoundary/ComponentErrorBoundary.d.ts

@@ -0,0 +1,9 @@
+import { ErrorFallbackProps } from '../BaseErrorBoundary/BaseErrorBoundary';
+interface ComponentErrorBoundaryProps {
+    children: React.ReactNode;
+    componentName?: string;
+    fallback?: React.ComponentType<ErrorFallbackProps>;
+    onError?: (error: Error, errorInfo: React.ErrorInfo, errorId: string) => void;
+}
+declare const ComponentErrorBoundary: React.FC<ComponentErrorBoundaryProps>;
+export default ComponentErrorBoundary;

package/error-boundaries/ErrorBoundaryTest/ErrorBoundaryTest.d.ts

@@ -0,0 +1,2 @@
+declare const ErrorBoundaryTest: React.FC;
+export default ErrorBoundaryTest;

package/error-boundaries/FlowBuilderErrorBoundary/FlowBuilderErrorBoundary.d.ts

@@ -0,0 +1,7 @@
+interface FlowBuilderErrorBoundaryProps {
+    children: React.ReactNode;
+    flowId?: string;
+    onError?: (error: Error, errorInfo: React.ErrorInfo, errorId: string) => void;
+}
+declare const FlowBuilderErrorBoundary: React.FC<FlowBuilderErrorBoundaryProps>;
+export default FlowBuilderErrorBoundary;

package/error-boundaries/index.d.ts

@@ -0,0 +1 @@
+export { default as FlowBuilderErrorBoundary } from './FlowBuilderErrorBoundary/FlowBuilderErrorBoundary';

package/features/condition-editor/components/ConditionEditor/ConditionEditor.d.ts

@@ -0,0 +1,17 @@
+import { ComponentCondition } from '../../../../../../core/src/index.ts';
+export interface ConditionGroup {
+    id: string;
+    conditions: ComponentCondition[];
+    logicalOperator: "and" | "OR";
+}
+export interface ConditionEditorProps {
+    componentId: string;
+    conditions: ComponentCondition[];
+    availableFields: Array<{
+        id: string;
+        label: string;
+    }>;
+    onUpdateConditions: (conditions: ComponentCondition[]) => void;
+}
+declare const ConditionEditor: React.FC<ConditionEditorProps>;
+export default ConditionEditor;

package/features/condition-editor/components/ConditionItem/ConditionItem.d.ts

@@ -0,0 +1,17 @@
+import { ComponentCondition } from '../../../../../../core/src/index.ts';
+interface ConditionItemProps {
+    condition: Partial<ComponentCondition>;
+    availableTargets: any[];
+    targetOptions: any[];
+    isTargetRadio?: boolean;
+    needsValueInput: boolean;
+    onUpdate: (updates: Partial<ComponentCondition>) => void;
+    onRemove: () => void;
+    canRemove?: boolean;
+    label?: string;
+    compact?: boolean;
+    isRequired?: boolean;
+    isIncomplete?: boolean;
+}
+declare const ConditionItem: React.FC<ConditionItemProps>;
+export default ConditionItem;

package/features/condition-editor/components/ConditionOperatorSelect/ConditionOperatorSelect.d.ts

@@ -0,0 +1,8 @@
+import { ConditionOperator } from '../../../../../../core/src/index.ts';
+interface ConditionOperatorSelectProps {
+    value: string;
+    onValueChange: (value: ConditionOperator) => void;
+    className?: string;
+}
+declare const ConditionOperatorSelect: React.FC<ConditionOperatorSelectProps>;
+export default ConditionOperatorSelect;

package/features/condition-editor/components/ConditionRow/ConditionRow.d.ts

@@ -0,0 +1,14 @@
+import { ComponentCondition, LogicalOperator } from '../../../../../../core/src/index.ts';
+interface ConditionRowProps {
+    condition: Partial<ComponentCondition>;
+    availableTargets: any[];
+    isFirst: boolean;
+    onUpdate: (updates: Partial<ComponentCondition>) => void;
+    onRemove: () => void;
+    logicalOperator: LogicalOperator;
+    onLogicalOperatorChange: (value: LogicalOperator) => void;
+    getTargetComponentOptions: (stepId: string, componentId: string) => any[];
+    isIncomplete?: boolean;
+}
+declare const ConditionRow: React.FC<ConditionRowProps>;
+export default ConditionRow;

package/features/condition-editor/components/ConditionSummary/ConditionSummary.d.ts

@@ -0,0 +1,7 @@
+import { ComponentCondition } from '../../../../../../core/src/index.ts';
+interface ConditionSummaryProps {
+    conditions: ComponentCondition[];
+    areConditionsMet: boolean;
+}
+declare const ConditionSummary: React.FC<ConditionSummaryProps>;
+export default ConditionSummary;

package/features/condition-editor/components/ConditionTargetSelect/ConditionTargetSelect.d.ts

@@ -0,0 +1,14 @@
+import { ComponentConfig } from '../../../../../../core/src/index.ts';
+interface TargetOption {
+    stepId: string;
+    stepTitle: string;
+    component: ComponentConfig;
+}
+interface ConditionTargetSelectProps {
+    value: string;
+    availableTargets: TargetOption[];
+    onTargetSelect: (stepId: string, componentId: string) => void;
+    className?: string;
+}
+declare const ConditionTargetSelect: React.FC<ConditionTargetSelectProps>;
+export default ConditionTargetSelect;

package/features/condition-editor/components/ConditionValueInput/ConditionValueInput.d.ts

@@ -0,0 +1,10 @@
+import { ComponentCondition } from '../../../../../../core/src/index.ts';
+interface ConditionValueInputProps {
+    condition: Partial<ComponentCondition>;
+    targetOptions: any[];
+    isTargetRadio: boolean;
+    onUpdate: (updates: Partial<ComponentCondition>) => void;
+    className?: string;
+}
+declare const ConditionValueInput: React.FC<ConditionValueInputProps>;
+export default ConditionValueInput;

package/features/condition-editor/components/EditConditionForm/EditConditionForm.d.ts

@@ -0,0 +1,13 @@
+import { ComponentCondition } from '../../../../../../core/src/index.ts';
+interface EditConditionFormProps {
+    condition: Partial<ComponentCondition>;
+    availableTargets: any[];
+    targetOptions: any[];
+    isTargetRadio: boolean;
+    needsValueInput: boolean;
+    onUpdate: (updates: Partial<ComponentCondition>) => void;
+    onSave: () => void;
+    onCancel: () => void;
+}
+declare const EditConditionForm: React.FC<EditConditionFormProps>;
+export default EditConditionForm;

package/features/condition-editor/components/ExistingCondition/ExistingCondition.d.ts

@@ -0,0 +1,13 @@
+import { ComponentCondition, RadioOption } from '../../../../../../core/src/index.ts';
+interface ExistingConditionProps {
+    condition: ComponentCondition;
+    targetStepTitle: string;
+    targetComponentLabel: string;
+    isTargetRadio: boolean;
+    targetOptions: RadioOption[];
+    onEdit: () => void;
+    onRemove: () => void;
+    disabled?: boolean;
+}
+declare const ExistingCondition: React.FC<ExistingConditionProps>;
+export default ExistingCondition;

package/features/condition-editor/components/LogicalConnector/LogicalConnector.d.ts

@@ -0,0 +1,8 @@
+import { LogicalOperator } from '../../../../../../core/src/index.ts';
+interface LogicalConnectorProps {
+    onSelect: (operator: LogicalOperator) => void;
+    onAddCondition: () => void;
+    selectedOperator: LogicalOperator;
+}
+declare const LogicalConnector: React.FC<LogicalConnectorProps>;
+export default LogicalConnector;

package/features/condition-editor/components/LogicalOperatorToggle/LogicalOperatorToggle.d.ts

@@ -0,0 +1,13 @@
+import { LogicalOperator } from '../../../../../../core/src/index.ts';
+interface LogicalOperatorToggleProps {
+    value: LogicalOperator;
+    onValueChange: (value: LogicalOperator) => void;
+    id?: string;
+    disabled?: boolean;
+    compact?: boolean;
+    showAddCondition?: boolean;
+    onAddCondition?: () => void;
+    isBetweenGroups?: boolean;
+}
+declare const LogicalOperatorToggle: React.FC<LogicalOperatorToggleProps>;
+export default LogicalOperatorToggle;

package/features/condition-editor/components/NewConditionBuilder/NewConditionBuilder.d.ts

@@ -0,0 +1,10 @@
+import { ComponentCondition } from '../../../../../../core/src/index.ts';
+interface NewConditionBuilderProps {
+    availableTargets: any[];
+    getTargetComponent: (stepId?: string, componentId?: string) => any;
+    getTargetComponentOptions: (stepId: string, componentId: string) => any[];
+    onAddConditions: (conditions: ComponentCondition[]) => void;
+    initialConditions?: ComponentCondition[];
+}
+declare const NewConditionBuilder: React.FC<NewConditionBuilderProps>;
+export default NewConditionBuilder;

package/features/condition-editor/components/NewConditionRow/NewConditionRow.d.ts

@@ -0,0 +1,15 @@
+import { ComponentCondition, LogicalOperator } from '../../../../../../core/src/index.ts';
+interface NewConditionRowProps {
+    condition: Partial<ComponentCondition>;
+    conditionIndex: number;
+    availableTargets: any[];
+    targetOptions: any[];
+    isTargetRadio: boolean;
+    needsValueInput: boolean;
+    logicalOperator: LogicalOperator;
+    onUpdateCondition: (index: number, updates: Partial<ComponentCondition>) => void;
+    onRemoveCondition: (index: number) => void;
+    onUpdateLogicalOperator: (value: LogicalOperator) => void;
+}
+declare const NewConditionRow: React.FC<NewConditionRowProps>;
+export default NewConditionRow;

package/features/condition-editor/components/VisibilityConditionBuilder/VisibilityConditionBuilder.d.ts

@@ -0,0 +1,17 @@
+import { ComponentConfig, VisibilityConditionConfig } from '../../../../../../core/src/index.ts';
+import { default as React } from 'react';
+interface AvailableField {
+    stepId: string;
+    stepTitle: string;
+    component: ComponentConfig;
+    fieldId: string;
+    label: string;
+}
+interface VisibilityConditionBuilderProps {
+    config: VisibilityConditionConfig | undefined;
+    onChange: (config: VisibilityConditionConfig | undefined) => void;
+    availableFields: AvailableField[];
+    className?: string;
+}
+export declare const VisibilityConditionBuilder: React.FC<VisibilityConditionBuilderProps>;
+export default VisibilityConditionBuilder;

package/features/condition-editor/components/hooks/useTargetComponents.d.ts

@@ -0,0 +1,6 @@
+import { FormWizardStep } from '../../../../../../core/src/index.ts';
+export declare const useTargetComponents: (steps: FormWizardStep[], currentStepId: string, currentComponentId: string) => {
+    availableTargets: any[];
+    getTargetComponent: (stepId?: string, componentId?: string) => any;
+    getTargetComponentOptions: (stepId: string, componentId: string) => any;
+};

package/features/condition-editor/components/utils/conditionUtils.d.ts

@@ -0,0 +1,7 @@
+import { ComponentCondition } from '../../../../../../core/src/index.ts';
+export declare const needsValueInput: (operator: string) => boolean;
+export declare const isAddConditionEnabled: (conditions: Partial<ComponentCondition>[]) => boolean;
+export declare const getOptionLabel: (value: string, options: any[]) => string;
+export declare const conditionIsComplete: (condition: Partial<ComponentCondition>) => boolean;
+export declare const areAllConditionsComplete: (conditions: Partial<ComponentCondition>[]) => boolean;
+export declare const isConditionFieldsRequired: (existingConditions: ComponentCondition[]) => boolean;

package/features/condition-editor/components/visibilityHelpers.d.ts

@@ -0,0 +1,21 @@
+import { ComponentConfig, FormWizardConfig, VisibilityConditionConfig } from '../../../../../core/src/index.ts';
+export interface AvailableField {
+    stepId: string;
+    stepTitle: string;
+    component: ComponentConfig;
+    fieldId: string;
+    label: string;
+}
+/**
+ * Extracts all available fields from the form configuration that can be used in visibility conditions
+ * Excludes the current component to prevent self-reference
+ */
+export declare function getAvailableFields(config: FormWizardConfig, currentStepId: string, currentComponentId: string): AvailableField[];
+/**
+ * Validates a visibility condition configuration
+ */
+export declare function validateVisibilityCondition(config: VisibilityConditionConfig, availableFields: AvailableField[]): string[];
+/**
+ * Creates a default visibility condition configuration
+ */
+export declare function createDefaultVisibilityConfig(): VisibilityConditionConfig;

package/features/condition-editor/index.d.ts

@@ -0,0 +1,17 @@
+export * from './components/ConditionEditor/ConditionEditor';
+export * from './components/ConditionItem/ConditionItem';
+export * from './components/ConditionOperatorSelect/ConditionOperatorSelect';
+export * from './components/ConditionRow/ConditionRow';
+export * from './components/ConditionSummary/ConditionSummary';
+export * from './components/ConditionTargetSelect/ConditionTargetSelect';
+export * from './components/ConditionValueInput/ConditionValueInput';
+export * from './components/EditConditionForm/EditConditionForm';
+export * from './components/ExistingCondition/ExistingCondition';
+export * from './components/hooks/useTargetComponents';
+export * from './components/LogicalConnector/LogicalConnector';
+export * from './components/LogicalOperatorToggle/LogicalOperatorToggle';
+export * from './components/NewConditionBuilder/NewConditionBuilder';
+export * from './components/NewConditionRow/NewConditionRow';
+export * from './components/utils/conditionUtils';
+export * from './components/VisibilityConditionBuilder/VisibilityConditionBuilder';
+export * from './components/visibilityHelpers';

package/features/dialog-system/components/ConfirmDialog.d.ts

@@ -0,0 +1,12 @@
+interface ConfirmDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    description: string;
+    confirmText?: string;
+    cancelText?: string;
+    variant?: "default" | "destructive";
+    onConfirm: () => void;
+}
+declare const ConfirmDialog: import('react').NamedExoticComponent<ConfirmDialogProps>;
+export { ConfirmDialog };