@digiform/builder 0.1.7 → 0.2.1

package/FormBuilder.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Form Builder Component - Main export for @libs/form-builder-component
+ *
+ * This is a publishable React component that provides a complete form building interface.
+ * It includes drag-and-drop functionality, property editing, and form configuration.
+ */
+export * from './features/condition-editor';
+export * from './features/dialog-system';
+export * from './features/form-builder';
+export { Canvas } from './features/form-builder/components/canvas/Canvas/Canvas';
+export { FormWizardComponentsPanel } from './features/form-builder/components/components-panel/FormWizardComponentsPanel/FormWizardComponentsPanel';
+export type { FormBuilderProps } from './features/form-builder/components/core/FormBuilder/FormBuilder';
+export { default as FormBuilder } from './features/form-builder/components/core/FormBuilder/FormBuilder';
+export { AdminPropertiesPanel } from './features/form-builder/components/editors/AdminPropertiesPanel/AdminPropertiesPanel';
+export * from './features/form-management';
+export type { FormExplorerProps } from './features/form-management/components/FormExplorer/FormExplorer';
+export { FormExplorer } from './features/form-management/components/FormExplorer/FormExplorer';
+export * from './features/property-editors';
+export * from './features/template-system';
+export { getAvailableGenericTemplatesSync, getTemplateInfo, validateTemplateReferences, } from './features/template-system/utils/templateUtils';
+export * from './features/trigger-action-system';
+export * from './features/visual-mapping';
+export * from './providers/FormSaveContext';
+export * from './utils/fileStorage';

package/client.d.ts

@@ -0,0 +1,18 @@
+export { isFormFieldComponent, renderComponent, } from './component-registry/components';
+export type { ComponentValue } from './component-registry/types';
+export { DEFAULT_FORM_CONFIG, type FormConfig, type FormStorageConfig, useFormConfiguration, } from './config';
+export { FlowBuilderErrorBoundary } from './error-boundaries';
+export * from './features/condition-editor';
+export * from './features/dialog-system';
+export * from './features/form-builder';
+export * from './features/property-editors';
+export * from './features/template-system';
+export { TemplateStorageService } from './features/template-system/services/TemplateStorageService';
+export * from './features/trigger-action-system';
+export * from './features/visual-mapping';
+export * from './providers';
+export type { CreateFormRequest, CreateProjectRequest, FileStorageError, FormBuilderSettings, FormFile, FormMetadata, FormStorageProvider, GenericTemplate, PersonalTemplate, SharedTemplate, StorageResult, TeamTemplate, TemplateCategory, TemplateCategoryInfo, TemplateDirectory, TemplateFile, TemplateStorageConfig, } from './storage/types';
+export type { ComponentConfig, FormSectionConfig, FormStepConfig, FormWizardConfig, StepNavigation, StepNavigationItem, StepTemplate, TemplateHistoryEntry, } from './store';
+export { useCanUndo, useCurrentSection, useFormBuilderActions, useFormBuilderStore, useFormConfig, useFormSteps, useHasUnsavedChanges, useIsSaving, useLastSavedAt, useSaveError, useSelectedSectionId, useSelectedStepId, } from './store';
+export * from './utils';
+export { getDatabaseConfig, resolveConfigVariables, } from './utils/configReader';

package/component-registry/components/alert.d.ts

@@ -0,0 +1,4 @@
+import { PropertyEditorSchema } from '../../features/property-editors/types/schema';
+import { ComponentDefinition } from '../types';
+export declare const alertPropertySchema: PropertyEditorSchema;
+export declare const alertComponent: ComponentDefinition;

package/component-registry/components/button.d.ts

@@ -0,0 +1,4 @@
+import { PropertyEditorSchema } from '../../features/property-editors/types/schema';
+import { ComponentDefinition } from '../types';
+export declare const buttonPropertySchema: PropertyEditorSchema;
+export declare const buttonComponent: ComponentDefinition;

package/component-registry/components/checkbox.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Checkbox Component - RHC Design System
+ *
+ * Uses FormFieldCheckboxGroup + FormFieldCheckboxOption pattern.
+ * This component uses customRenderComponent because the Group+Option pattern
+ * doesn't fit the standard FormFieldWrapper template used by other components.
+ */
+export declare const checkboxComponent: import('../types').ComponentDefinition;
+export declare const checkboxPropertySchema: import('../..').PropertyEditorSchema | undefined;

package/component-registry/components/code-input/code-input.d.ts

@@ -0,0 +1,4 @@
+import { PropertyEditorSchema } from '../../../features/property-editors/types/schema';
+import { ComponentDefinition } from '../../types';
+export declare const codeInputPropertySchema: PropertyEditorSchema;
+export declare const codeInputComponent: ComponentDefinition;

package/component-registry/components/dropdown.d.ts

@@ -0,0 +1 @@
+export declare const dropdownComponent: import('..').ComponentDefinition;

package/component-registry/components/heading.d.ts

@@ -0,0 +1,4 @@
+import { PropertyEditorSchema } from '../../features/property-editors/types/schema';
+import { ComponentDefinition } from '../types';
+export declare const headingPropertySchema: PropertyEditorSchema;
+export declare const headingComponent: ComponentDefinition;

package/component-registry/components/index.d.ts

@@ -0,0 +1,35 @@
+import { ComponentConfig } from '../../../../core/src/index.ts';
+import { ComponentDefinition, ComponentRegistry, ComponentValue } from '../types';
+export { alertComponent, alertPropertySchema } from './alert';
+export { buttonComponent, buttonPropertySchema } from './button';
+export { checkboxComponent, checkboxPropertySchema } from './checkbox';
+export { codeInputComponent, codeInputPropertySchema } from './code-input/code-input';
+export { dropdownComponent } from './dropdown';
+export { headingComponent, headingPropertySchema } from './heading';
+export { paragraphComponent, paragraphPropertySchema } from './paragraph';
+export { progressLoaderComponent, progressLoaderPropertySchema, } from './progress-loader';
+export { radioGroupComponent } from './radioGroup';
+export { textComponent, textInputPropertySchema } from './text';
+export { textareaComponent, textareaPropertySchema } from './textarea';
+declare const emailComponent: ComponentDefinition;
+declare const telComponent: ComponentDefinition;
+declare const numberComponent: ComponentDefinition;
+declare const dateComponent: ComponentDefinition;
+export { emailComponent, telComponent, numberComponent, dateComponent };
+export { createComponentDefinition, createGenericPropertyEditor, } from '../utils';
+export declare const componentRegistry: ComponentRegistry;
+export declare const getComponentDefinition: (type: string) => ComponentDefinition;
+export declare const getAllComponentDefinitions: () => ComponentDefinition[];
+export declare const renderComponentEditor: (props: {
+    component: ComponentConfig;
+    stepId: string;
+    handlePropertyChange: (field: string, value: ComponentValue) => void;
+    handleChange: (field: string, value: ComponentValue) => void;
+}) => string | number | boolean | Iterable<import('react').ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+export declare const renderComponent: (props: {
+    component: ComponentConfig;
+    value: ComponentValue;
+    onChange: (value: ComponentValue) => void;
+    isFormView: boolean;
+}) => string | number | boolean | Iterable<import('react').ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+export declare const isFormFieldComponent: (componentType: string) => boolean;

package/component-registry/components/paragraph.d.ts

@@ -0,0 +1,4 @@
+import { PropertyEditorSchema } from '../../features/property-editors/types/schema';
+import { ComponentDefinition } from '../types';
+export declare const paragraphPropertySchema: PropertyEditorSchema;
+export declare const paragraphComponent: ComponentDefinition;

package/component-registry/components/progress-loader.d.ts

@@ -0,0 +1,4 @@
+import { PropertyEditorSchema } from '../../features/property-editors/types/schema';
+import { ComponentDefinition } from '../types';
+export declare const progressLoaderPropertySchema: PropertyEditorSchema;
+export declare const progressLoaderComponent: ComponentDefinition;

package/component-registry/components/radioGroup.d.ts

@@ -0,0 +1 @@
+export declare const radioGroupComponent: import('..').ComponentDefinition;

package/component-registry/components/text.d.ts

@@ -0,0 +1,2 @@
+export declare const textComponent: import('..').ComponentDefinition;
+export declare const textInputPropertySchema: import('../..').PropertyEditorSchema | undefined;

package/component-registry/components/textarea.d.ts

@@ -0,0 +1,2 @@
+export declare const textareaComponent: import('..').ComponentDefinition;
+export declare const textareaPropertySchema: import('../..').PropertyEditorSchema | undefined;

package/component-registry/createFormFieldComponent.d.ts

@@ -0,0 +1,52 @@
+import { ComponentConfig, ComponentType } from '../../../core/src/index.ts';
+import { ReactNode } from 'react';
+import { ComponentPropsConfig } from '../design-system/rhc/utils/create-config';
+import { ComponentDefinition, ComponentEditorProps, ComponentRendererProps } from './types';
+/**
+ * Configuration for creating a form field component
+ */
+export interface FormFieldComponentConfig {
+    type: ComponentType;
+    label: string;
+    icon: string;
+    designSystemComponent: string;
+    propsConfig: ComponentPropsConfig;
+    defaultConfig: Omit<ComponentConfig, "id">;
+    RHCComponent: React.ComponentType<any>;
+    valueConfig: {
+        type: "string" | "boolean" | "string-or-number";
+        defaultValue: string | boolean | number;
+        onChangeExtractor: "event-target-value" | "event-target-checked" | "direct";
+    };
+    transformProps?: (rhcProps: Record<string, unknown>, context: {
+        component: ComponentConfig;
+        isFormView: boolean;
+    }) => Record<string, unknown>;
+    customRenderComponent?: (props: ComponentRendererProps) => ReactNode;
+    customEditor?: (props: ComponentEditorProps) => ReactNode;
+}
+/**
+ * Factory function that creates a complete ComponentDefinition from RHC config
+ *
+ * This is the central piece that eliminates manual prop mapping and scattered type casts.
+ * By iterating propsConfig.props to build mapProps, adding new RHC props becomes a
+ * config-only change. The centralized `as any` cast in the factory replaces 5 scattered casts.
+ *
+ * @param config - Form field component configuration
+ * @returns Complete ComponentDefinition compatible with the existing registry
+ *
+ * @example
+ * ```ts
+ * const textComponent = createFormFieldComponent({
+ *   type: "text",
+ *   label: "Tekst invoer",
+ *   icon: "text-input",
+ *   designSystemComponent: "FormFieldTextInput",
+ *   propsConfig: textInputConfig,
+ *   defaultConfig: { ... },
+ *   RHCComponent: FormFieldTextInput,
+ *   valueConfig: { type: "string", defaultValue: "", onChangeExtractor: "event-target-value" }
+ * });
+ * ```
+ */
+export declare function createFormFieldComponent(config: FormFieldComponentConfig): ComponentDefinition;

package/component-registry/index.d.ts

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

package/component-registry/types.d.ts

@@ -0,0 +1,42 @@
+import { PropertyEditorSchema } from '../features/property-editors/types/schema';
+import { ComponentConfig, ComponentType } from '../../../core/src/index.ts';
+import { ComponentSource } from '../../../ui/src/design-system/index.ts';
+import { ChangeEvent, ReactNode } from 'react';
+import { ComponentValidationCapabilities } from './validation';
+export interface DesignSystemBaseProps {
+    [key: string]: unknown;
+}
+export type InputChangeEvent = ChangeEvent<HTMLInputElement>;
+export type TextareaChangeEvent = ChangeEvent<HTMLTextAreaElement>;
+export type SelectChangeEvent = ChangeEvent<HTMLSelectElement>;
+export type ComponentValue = string | boolean | number | null | undefined | unknown[];
+export interface ComponentEditorProps {
+    component: ComponentConfig;
+    stepId: string;
+    handlePropertyChange: (field: string, value: ComponentValue) => void;
+    handleChange: (field: string, value: ComponentValue) => void;
+    disabled?: boolean;
+}
+export interface ComponentRendererProps {
+    component: ComponentConfig;
+    value: ComponentValue;
+    onChange: (value: ComponentValue) => void;
+    isFormView: boolean;
+}
+export interface ComponentDefinition {
+    type: ComponentType;
+    label: string;
+    icon: string;
+    category: "formFields" | "typography" | "feedback";
+    source: ComponentSource;
+    defaultConfig: Omit<ComponentConfig, "id">;
+    designSystemComponent: string;
+    propertyEditorSchema?: PropertyEditorSchema;
+    validationCapabilities?: ComponentValidationCapabilities;
+    mapProps: (component: ComponentConfig, value?: ComponentValue) => DesignSystemBaseProps;
+    renderEditor: (props: ComponentEditorProps) => ReactNode;
+    renderComponent: (props: ComponentRendererProps) => ReactNode;
+}
+export interface ComponentRegistry {
+    [key: string]: ComponentDefinition;
+}

package/component-registry/utils.d.ts

@@ -0,0 +1,33 @@
+import { PropertyEditorSchema } from '../features/property-editors/types/schema';
+import { ComponentConfig, ComponentType } from '../../../core/src/index.ts';
+import { ComponentSource } from '../../../ui/src/design-system/index.ts';
+import { ReactNode } from 'react';
+import { ComponentDefinition, ComponentEditorProps, ComponentValue } from './types';
+/**
+ * Helper function to create a generic property editor from a schema
+ * @param schema The property editor schema
+ * @returns A React component that renders the property editor
+ */
+export declare const createGenericPropertyEditor: (schema: PropertyEditorSchema) => (props: ComponentEditorProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Automatically creates a component definition with generic property editor
+ * @param config Component configuration
+ * @returns Complete component definition
+ */
+export declare const createComponentDefinition: (config: {
+    type: ComponentType;
+    label: string;
+    icon: string;
+    category: "formFields" | "typography" | "feedback";
+    source?: ComponentSource;
+    designSystemComponent?: string;
+    defaultConfig: Omit<ComponentConfig, "id">;
+    propertyEditorSchema: PropertyEditorSchema;
+    mapProps?: (component: ComponentConfig, value?: ComponentValue) => Record<string, unknown>;
+    renderComponent: (props: {
+        component: ComponentConfig;
+        value: ComponentValue;
+        onChange: (value: ComponentValue) => void;
+        isFormView: boolean;
+    }) => ReactNode;
+}) => ComponentDefinition;

package/component-registry/validation.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Validation Rule Configuration System
+ *
+ * This module defines the comprehensive validation rule system for the form builder,
+ * including validation rule definitions, component validation capabilities, and
+ * runtime validation configuration.
+ */
+/**
+ * Defines the parameter types that validation rules can accept
+ */
+export type ValidationParameterType = "boolean" | "number" | "string" | "array" | "object";
+/**
+ * Configuration for validation rule parameters
+ */
+export interface ValidationRuleParameter {
+    /** Parameter name (e.g., 'value', 'message') */
+    name: string;
+    /** Parameter type for UI rendering */
+    type: ValidationParameterType;
+    /** Display label for the parameter */
+    label: string;
+    /** Help text describing the parameter */
+    description?: string;
+    /** Whether this parameter is required */
+    required: boolean;
+    /** Default value for the parameter */
+    defaultValue?: string | number | boolean;
+    /** Minimum value (for number type) */
+    min?: number;
+    /** Maximum value (for number type) */
+    max?: number;
+    /** Placeholder text (for string type) */
+    placeholder?: string;
+    /** Predefined options (for select-style inputs) */
+    options?: Array<{
+        label: string;
+        value: string | number | boolean;
+    }>;
+}
+/**
+ * Complete validation rule definition
+ */
+export interface ValidationRuleDefinition {
+    /** Unique identifier for the rule */
+    id: string;
+    /** Display name for the rule */
+    label: string;
+    /** Detailed description of what this rule validates */
+    description: string;
+    /** Category for grouping rules in UI */
+    category: "basic" | "length" | "format" | "numeric" | "selection" | "custom";
+    /** Parameters that can be configured for this rule */
+    parameters: ValidationRuleParameter[];
+    /** Default error message template */
+    defaultMessage: string;
+    /** Whether this rule can be combined with others */
+    combinable: boolean;
+    /** Priority for rule execution order (lower = higher priority) */
+    priority: number;
+}
+/**
+ * Runtime configuration for a specific validation rule instance
+ */
+export interface ValidationRuleInstance {
+    /** Reference to the rule definition */
+    ruleId: string;
+    /** Whether this rule is enabled */
+    enabled: boolean;
+    /** Configured parameters for this rule instance */
+    parameters: Record<string, string | number | boolean>;
+    /** Custom error message (overrides default) */
+    customMessage?: string;
+}
+/**
+ * Component's validation configuration
+ */
+export interface ComponentValidationConfig {
+    /** All configured validation rule instances */
+    rules: ValidationRuleInstance[];
+    /** Overall validation enabled/disabled */
+    enabled: boolean;
+    /** Validation timing preferences */
+    timing?: {
+        /** Validate on blur */
+        onBlur?: boolean;
+        /** Validate on change */
+        onChange?: boolean;
+        /** Validate on submit */
+        onSubmit?: boolean;
+    };
+    /** Message display style */
+    messageStyle?: "withLabel" | "simple";
+}
+/**
+ * Defines which validation rules a component type supports
+ */
+export interface ComponentValidationCapabilities {
+    /** Component type this applies to */
+    componentType: string;
+    /** List of supported validation rule IDs */
+    supportedRules: string[];
+    /** Default rules that should be enabled for new components */
+    defaultRules?: string[];
+    /** Custom validation rule definitions specific to this component */
+    customRules?: ValidationRuleDefinition[];
+}
+/**
+ * Comprehensive catalog of all available validation rules
+ */
+export declare const VALIDATION_RULES: ValidationRuleDefinition[];
+/**
+ * Defines validation capabilities for each component type
+ */
+export declare const COMPONENT_VALIDATION_CAPABILITIES: ComponentValidationCapabilities[];
+/**
+ * Gets validation rule definition by ID
+ */
+export declare const getValidationRuleDefinition: (ruleId: string) => ValidationRuleDefinition | undefined;
+/**
+ * Gets validation capabilities for a component type
+ */
+export declare const getComponentValidationCapabilities: (componentType: string) => ComponentValidationCapabilities | undefined;
+/**
+ * Creates a default validation configuration for a component type
+ */
+export declare const createDefaultValidationConfig: (componentType: string) => ComponentValidationConfig;
+/**
+ * Gets default parameters for a validation rule
+ */
+export declare const getDefaultRuleParameters: (ruleId: string) => Record<string, string | number | boolean>;
+/**
+ * Validates a validation configuration against component capabilities
+ */
+export declare const validateValidationConfig: (componentType: string, config: ComponentValidationConfig) => {
+    isValid: boolean;
+    errors: string[];
+};
+/**
+ * Groups validation rules by category for UI display
+ */
+export declare const getValidationRulesByCategory: () => Record<string, ValidationRuleDefinition[]>;

package/component-registry/validationBridge.d.ts

@@ -0,0 +1,10 @@
+import { ComponentValidation } from '../../../core/src/index.ts';
+import { ComponentValidationConfig } from './validation';
+/**
+ * Converts from admin validation config (ComponentValidationConfig) to user validation format (ComponentValidation)
+ */
+export declare function convertToUserValidation(adminConfig: ComponentValidationConfig): ComponentValidation | undefined;
+/**
+ * Converts from user validation format (ComponentValidation) to admin validation config (ComponentValidationConfig)
+ */
+export declare function convertFromUserValidation(userValidation: ComponentValidation | undefined): ComponentValidationConfig;

package/components/ConnectionErrorScreen/ConnectionErrorScreen.d.ts

@@ -0,0 +1,10 @@
+/**
+ * ConnectionErrorScreen - Shows when database is not available
+ * Blocks UI to prevent user actions that won't work without database connection
+ */
+interface ConnectionErrorScreenProps {
+    onRetry?: () => void;
+    className?: string;
+}
+export declare const ConnectionErrorScreen: React.FC<ConnectionErrorScreenProps>;
+export {};

package/components/DatabaseStatusIndicator/DatabaseStatusIndicator.d.ts

@@ -0,0 +1,24 @@
+interface SyncStatus {
+    online: boolean;
+    connected: boolean;
+    connectionStatus: "connected" | "disconnected" | "connecting" | "retrying";
+    lastSync: string | null;
+    syncing: boolean;
+    retryCount?: number;
+    maxRetries?: number;
+    lastConnectionError?: string | null;
+    pendingOperations?: number;
+    reconciling?: boolean;
+    integrityStatus?: "consistent" | "inconsistent" | "unknown";
+}
+interface DatabaseStatusIndicatorProps {
+    className?: string;
+    getSyncStatus?: () => SyncStatus;
+    onForceSync?: () => Promise<void>;
+    onReconnect?: () => Promise<boolean>;
+    onValidateConsistency?: () => Promise<boolean>;
+    onResetLocalData?: () => Promise<boolean>;
+    onReconcileConflicts?: () => Promise<boolean>;
+}
+export declare const DatabaseStatusIndicator: ({ className, getSyncStatus, onForceSync, onReconnect, onValidateConsistency, onResetLocalData, onReconcileConflicts, }: DatabaseStatusIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/config/SecureConfigLoader.d.ts

@@ -0,0 +1,57 @@
+import { FormConfig } from './types';
+export interface VaultConfig {
+    address: string;
+    token?: string;
+    namespace?: string;
+}
+export interface SecureConfigOptions {
+    vault?: VaultConfig;
+    enableVault?: boolean;
+    envPrefix?: string;
+}
+export declare class SecureConfigLoader {
+    private vaultConfig?;
+    private enableVault;
+    private envPrefix;
+    constructor(options?: SecureConfigOptions);
+    /**
+     * Load and process configuration with secure credential handling
+     */
+    loadSecureConfig(configPath: string): Promise<FormConfig>;
+    /**
+     * Process configuration object with secure substitutions
+     */
+    processSecureConfig(config: any): Promise<FormConfig>;
+    /**
+     * Read configuration file (in browser, this would come from the server)
+     */
+    private readConfigFile;
+    /**
+     * Substitute secure values in configuration string
+     */
+    private substituteSecureValues;
+    /**
+     * Substitute environment variables
+     */
+    private substituteEnvironmentVariables;
+    /**
+     * Substitute Vault values (CI/CD environment)
+     */
+    private substituteVaultValues;
+    /**
+     * Fetch secret from Vault
+     */
+    private fetchFromVault;
+    /**
+     * Validate database connection configuration
+     */
+    validateDatabaseConfig(config: FormConfig): boolean;
+    /**
+     * Create configuration for different environments
+     */
+    static createForEnvironment(): SecureConfigLoader;
+}
+/**
+ * Simple helper for loading configuration in applications
+ */
+export declare function loadSecureFormConfig(configPath: string): Promise<FormConfig>;

package/config/hooks.d.ts

@@ -0,0 +1,2 @@
+import { FormConfig } from './types';
+export declare function useFormConfiguration(): FormConfig | undefined;

package/config/index.d.ts

@@ -0,0 +1,5 @@
+export { useFormConfiguration } from './hooks';
+export type { SecureConfigOptions, VaultConfig } from './SecureConfigLoader';
+export { loadSecureFormConfig, SecureConfigLoader } from './SecureConfigLoader';
+export type { DatabaseConfig, FormConfig, FormStorageConfig, } from './types';
+export { createConfigFromEnvironment, DEFAULT_FORM_CONFIG } from './types';

package/config/types.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Unified configuration types for the form builder system
+ * Single source of truth for all form configuration needs
+ */
+/**
+ * Database configuration for database storage strategy
+ * Simplified configuration - always uses PgLite with local-first approach and mandatory sync
+ */
+export interface DatabaseConfig {
+    /** Database connection string (required for database strategy) */
+    connectionString: string;
+    /** Optional service role key for authentication (only needed for some providers like Supabase) */
+    serviceRoleKey?: string;
+}
+/**
+ * Unified form storage configuration
+ * Supports filesystem and database (PgLite-based) storage strategies
+ */
+export interface FormStorageConfig {
+    /** Storage strategy to use. Use "none" when the app handles persistence externally. */
+    strategy: "filesystem" | "database" | "none";
+    /** Path configuration for filesystem storage */
+    paths?: {
+        /** Primary storage directory for forms */
+        primaryStorage: string;
+        /** Template directories */
+        templates?: {
+            /** Team templates directory */
+            team?: string;
+            /** Generic templates directory */
+            generic?: string;
+        };
+        /** Fallback paths for form loading */
+        fallbackPaths?: string[];
+        /** Static assets directory */
+        staticAssets?: string;
+    };
+    /** Database configuration (required when strategy is "database") */
+    databaseConfig?: DatabaseConfig;
+    /** File extension for form files (filesystem strategy) */
+    fileExtension?: string;
+    /** Whether to automatically create directories (filesystem strategy) */
+    createDirectories?: boolean;
+}
+/**
+ * Route configuration for form builder navigation
+ * Supports URL patterns with parameters like :project and :wizardId
+ */
+export interface RouteConfig {
+    /** Projects page route (e.g., "/forms", "/projects") */
+    projects?: string;
+    /** Forms list page route (e.g., "/forms/:project", "/projects/:project/forms") */
+    forms?: string;
+    /** Form builder page route (e.g., "/forms/:project/:wizardId", "/builder/:project/:wizardId") */
+    builder?: string;
+    /** Form preview page route (e.g., "/forms/:project/:wizardId/preview") */
+    preview?: string;
+}
+/**
+ * Complete form configuration with storage, URLs, metadata, and theme support
+ */
+export interface FormConfig {
+    /** Storage configuration */
+    storage: FormStorageConfig;
+    /** URL configuration for previews and navigation */
+    urls?: {
+        /** Base URL for form previews */
+        previewBase?: string;
+        /** Preview path template */
+        previewPath?: string;
+    };
+    /** Route configuration for navigation */
+    routes?: RouteConfig;
+    /** Configuration metadata */
+    metadata?: {
+        /** Configuration version */
+        version?: string;
+        /** Last update timestamp */
+        lastUpdated?: string;
+    };
+    /** Theme configuration */
+    theme?: {
+        /** Theme name */
+        name?: string;
+    };
+}
+/**
+ * Default configuration values
+ */
+export declare const DEFAULT_FORM_CONFIG: FormConfig;
+/**
+ * Creates configuration from environment variables
+ */
+export declare const createConfigFromEnvironment: () => FormConfig;