@digiform/builder 0.1.7 → 0.2.1

package/features/form-builder/components/steps/StepLockIndicator/StepLockIndicator.d.ts

@@ -0,0 +1,18 @@
+import { FormStepConfig, TemplateStepConfig } from '../../../../../../../core/src/index.ts';
+interface StepLockIndicatorProps {
+    step: FormStepConfig | TemplateStepConfig;
+    templateOrigin?: {
+        templateId: string;
+        stepIndex?: number;
+    };
+    className?: string;
+}
+/**
+ * StepLockIndicator component displays lock icons for template steps with informative tooltips.
+ *
+ * - Generic template steps: Shows lock icon with explanation about organizational standards
+ * - Team template steps: Shows users icon with explanation about team templates
+ * - Regular steps: No indicator shown
+ */
+export declare const StepLockIndicator: React.FC<StepLockIndicatorProps>;
+export default StepLockIndicator;

package/features/form-builder/components/steps/StepsList/StepsList.d.ts

@@ -0,0 +1,3 @@
+declare const StepsList: React.FC;
+export { StepsList };
+export default StepsList;

package/features/form-builder/components/steps/index.d.ts

@@ -0,0 +1,8 @@
+export type * from './AdminStepSettings/AdminStepSettings';
+export { default as AdminStepSettings } from './AdminStepSettings/AdminStepSettings';
+export type * from './SortableStepItem/SortableStepItem';
+export { default as SortableStepItem } from './SortableStepItem/SortableStepItem';
+export type * from './StepLockIndicator/StepLockIndicator';
+export { default as StepLockIndicator } from './StepLockIndicator/StepLockIndicator';
+export type * from './StepsList/StepsList';
+export { default as StepsList } from './StepsList/StepsList';

package/features/form-builder/context/FormBuilderContext.d.ts

@@ -0,0 +1,30 @@
+import { FormSectionConfig, FormStepConfig, FormWizardConfig, TemplateStepConfig } from '../../../../../core/src/index.ts';
+import { ReactNode } from 'react';
+interface FormBuilderContextValue {
+    formConfig: FormWizardConfig;
+    selectedStepId: string | null;
+    selectedSectionId: string | null;
+    currentStep: FormStepConfig | TemplateStepConfig | null;
+    currentSection: FormSectionConfig | null;
+    updateFormConfig: (config: FormWizardConfig) => void;
+    updateFormTitle: (title: string) => void;
+    setSelectedStepId: (stepId: string | null) => void;
+    addStep: () => FormStepConfig;
+    updateStep: (stepId: string, updates: Partial<FormStepConfig>) => void;
+    deleteStep: (stepId: string) => void;
+    reorderSteps: (steps: FormStepConfig[]) => void;
+    setSelectedSectionId: (sectionId: string | null) => void;
+    addSection: (stepId: string) => FormSectionConfig;
+    updateSection: (stepId: string, sectionId: string, updatedSection: FormSectionConfig) => void;
+    deleteSection: (stepId: string, sectionId: string) => void;
+    reorderSections: (stepId: string, sections: FormSectionConfig[]) => void;
+}
+export declare const FormBuilderContext: () => import('react').Context<FormBuilderContextValue | null>;
+interface FormBuilderProviderProps {
+    children: ReactNode;
+    initialConfig: FormWizardConfig;
+    onConfigChange?: (config: FormWizardConfig) => void;
+}
+export declare const FormBuilderProvider: React.FC<FormBuilderProviderProps>;
+export declare const useFormBuilderContext: () => FormBuilderContextValue;
+export {};

package/features/form-builder/context/ResolvedStepContext.d.ts

@@ -0,0 +1,9 @@
+import { FormStepConfig } from '../../../../../core/src/index.ts';
+import { default as React } from 'react';
+interface ResolvedStepProviderProps {
+    children: React.ReactNode;
+    resolvedStep: FormStepConfig | null;
+}
+export declare const ResolvedStepProvider: React.FC<ResolvedStepProviderProps>;
+export declare const useResolvedStep: () => FormStepConfig | null;
+export {};

package/features/form-builder/hooks/useCurrentStep.d.ts

@@ -0,0 +1,18 @@
+import { FormSectionConfig, FormStepConfig, TemplateStepConfig } from '../../../../../core/src/index.ts';
+export interface UseCurrentStepReturn {
+    currentStep: FormStepConfig | TemplateStepConfig | null;
+    stepIndex: number;
+    isFirstStep: boolean;
+    isLastStep: boolean;
+    updateCurrentStep: (updates: Partial<FormStepConfig>) => void;
+    updateStepTitle: (title: string) => void;
+    sections: FormSectionConfig[];
+    selectedSectionId: string | null;
+    currentSection: FormSectionConfig | null;
+    setSelectedSectionId: (sectionId: string | null) => void;
+    addSection: () => FormSectionConfig;
+    updateCurrentSection: (updatedSection: FormSectionConfig) => void;
+    deleteSection: (sectionId: string) => void;
+    reorderSections: (sections: FormSectionConfig[]) => void;
+}
+export declare const useCurrentStep: () => UseCurrentStepReturn;

package/features/form-builder/hooks/useDragAndDrop.d.ts

@@ -0,0 +1,16 @@
+import { DragEndEvent, DragOverEvent, DragStartEvent } from '@dnd-kit/core';
+import { ComponentConfig, FormSectionConfig, FormStepConfig } from '../../../../../core/src/index.ts';
+interface DragState {
+    activeId: string | null;
+    activeComponent: ComponentConfig | null;
+    activeSection: FormSectionConfig | null;
+    dragType: "component" | "section" | null;
+    isDragging: boolean;
+}
+export declare function useDragAndDrop(currentStep: FormStepConfig): {
+    dragState: DragState;
+    handleDragStart: (event: DragStartEvent) => void;
+    handleDragOver: (event: DragOverEvent) => void;
+    handleDragEnd: (event: DragEndEvent) => void;
+};
+export {};

package/features/form-builder/hooks/useDragFeedback.d.ts

@@ -0,0 +1,32 @@
+interface DragFeedbackState {
+    isDragOver: boolean;
+    dragOverSection: string | null;
+    dragOverIndex: number | null;
+    insertionIndicator: {
+        sectionId: string;
+        index: number;
+    } | null;
+    isDragActive: boolean;
+    dragType: "component" | "section" | null;
+    dragOverDropIndicator: string | null;
+    sectionHoldProgress: Record<string, number>;
+}
+export declare function useDragFeedback(): {
+    feedbackState: DragFeedbackState;
+    startDrag: (dragType: "component" | "section") => void;
+    endDrag: () => void;
+    showDropZone: (sectionId: string) => void;
+    hideDropZone: () => void;
+    showInsertionIndicator: (sectionId: string, index: number) => void;
+    hideInsertionIndicator: () => void;
+    showDropIndicatorFeedback: (dropIndicatorId: string) => void;
+    hideDropIndicatorFeedback: () => void;
+    setSectionHoldProgress: (sectionId: string, progress: number) => void;
+    clearSectionHoldProgress: (sectionId: string) => void;
+    clearAllFeedback: () => void;
+    isDropZoneActive: (sectionId: string) => boolean;
+    isInsertionIndicatorActive: (sectionId: string, index: number) => boolean;
+    isDropIndicatorActive: (dropIndicatorId: string) => boolean;
+    getSectionHoldProgress: (sectionId: string) => number;
+};
+export {};

package/features/form-builder/hooks/useHoldToDrag.d.ts

@@ -0,0 +1,18 @@
+interface UseHoldToDragProps {
+    holdDelay?: number;
+    onHoldStart?: () => void;
+    onHoldComplete?: () => void;
+    onHoldCancel?: () => void;
+}
+interface HoldToDragState {
+    isHolding: boolean;
+    isHoldComplete: boolean;
+    holdProgress: number;
+}
+export declare function useHoldToDrag({ holdDelay, onHoldStart, onHoldComplete, onHoldCancel, }?: UseHoldToDragProps): {
+    holdState: HoldToDragState;
+    startHold: () => void;
+    cancelHold: () => void;
+    resetHold: () => void;
+};
+export {};

package/features/form-builder/hooks/usePreviewConfig.d.ts

@@ -0,0 +1,23 @@
+import { PreviewConfig } from '../components/buttons/PreviewButton/PreviewButton';
+/**
+ * Form configuration structure (partial)
+ */
+interface FormConfig {
+    urls?: {
+        previewBase?: string;
+        previewPath?: string;
+    };
+}
+/**
+ * Hook to get preview configuration
+ *
+ * @param formConfig Optional form configuration object
+ * @returns Preview configuration for PreviewButton
+ */
+export declare const usePreviewConfig: (formConfig?: FormConfig) => PreviewConfig;
+/**
+ * Hook to load preview configuration from file system
+ * This is a placeholder that can be extended to actually read from form.config.json
+ */
+export declare const useLoadedPreviewConfig: () => PreviewConfig;
+export default usePreviewConfig;

package/features/form-builder/hooks/useSectionOperations.d.ts

@@ -0,0 +1,7 @@
+import { FormStepConfig } from '../../../../../core/src/index.ts';
+export declare function useSectionOperations(currentStep: FormStepConfig | null): {
+    addSection: () => void;
+    moveSection: (sectionId: string, direction: "up" | "down") => void;
+    deleteSection: (sectionId: string) => void;
+    canDeleteSection: (_sectionId: string) => boolean;
+};

package/features/form-builder/index.d.ts

@@ -0,0 +1,10 @@
+export * from './components';
+export * from './hooks/useCurrentStep';
+export * from './hooks/useDragAndDrop';
+export * from './hooks/useDragFeedback';
+export * from './hooks/useHoldToDrag';
+export * from './hooks/useSectionOperations';
+export * from './providers/DragAndDropProvider/DragAndDropProvider';
+export * from './utils/bodyConversionUtils';
+export * from './utils/collisionDetection';
+export * from './utils/PropertyLockIndicator/PropertyLockIndicator';

package/features/form-builder/providers/DragAndDropProvider/DragAndDropProvider.d.ts

@@ -0,0 +1,8 @@
+import { FormStepConfig } from '../../../../../../core/src/index.ts';
+interface DragAndDropProviderProps {
+    children: React.ReactNode;
+    currentStep: FormStepConfig;
+    isLocked?: boolean;
+}
+export declare function DragAndDropProvider({ children, currentStep, isLocked, }: DragAndDropProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/features/form-builder/utils/PropertyLockIndicator/PropertyLockIndicator.d.ts

@@ -0,0 +1,30 @@
+interface PropertyLockIndicatorProps {
+    /** Whether this property is locked */
+    isLocked: boolean;
+    /** Custom tooltip message explaining why the property is locked */
+    tooltip?: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Size variant for the lock icon */
+    size?: "sm" | "md";
+}
+/**
+ * PropertyLockIndicator component displays a small lock icon next to property labels
+ * when they are locked due to template governance rules.
+ *
+ * Used for individual form properties that cannot be edited in generic templates.
+ */
+export declare const PropertyLockIndicator: React.FC<PropertyLockIndicatorProps>;
+/**
+ * PropertyLockWrapper component wraps form controls to make them read-only when locked
+ */
+interface PropertyLockWrapperProps {
+    /** Whether this property is locked */
+    isLocked: boolean;
+    /** The form control to wrap */
+    children: React.ReactNode;
+    /** Custom tooltip message */
+    tooltip?: string;
+}
+export declare const PropertyLockWrapper: React.FC<PropertyLockWrapperProps>;
+export {};

package/features/form-builder/utils/bodyConversionUtils.d.ts

@@ -0,0 +1,35 @@
+import { ApiBodyField } from '../../../../../core/src/index.ts';
+/**
+ * Interface for a key-value pair in the editor
+ */
+export interface BodyFieldEntry {
+    id: string;
+    key: string;
+    value: string;
+    type: "static" | "dynamic";
+    fieldPath?: string;
+}
+/**
+ * Converts a body object to an array of BodyFieldEntry items for the key-value editor
+ */
+export declare function bodyObjectToFields(bodyObject: Record<string, unknown>): BodyFieldEntry[];
+/**
+ * Converts an array of BodyFieldEntry items to a body object
+ */
+export declare function fieldsToBodyObject(fields: BodyFieldEntry[]): Record<string, unknown>;
+/**
+ * Validates if a string is valid JSON
+ */
+export declare function isValidJSON(str: string): boolean;
+/**
+ * Safely parses JSON string, returns empty object if invalid
+ */
+export declare function safeParseJSON(str: string): Record<string, unknown>;
+/**
+ * Converts legacy ApiBodyField format to BodyFieldEntry format
+ */
+export declare function apiBodyFieldToBodyFieldEntry(apiField: ApiBodyField): BodyFieldEntry;
+/**
+ * Converts BodyFieldEntry format to legacy ApiBodyField format
+ */
+export declare function bodyFieldEntryToApiBodyField(entry: BodyFieldEntry): ApiBodyField;

package/features/form-builder/utils/collisionDetection.d.ts

@@ -0,0 +1,6 @@
+import { CollisionDetection } from '@dnd-kit/core';
+/**
+ * Enhanced collision detection that prioritizes drop indicators and provides better UX
+ * Designed to prevent component removal bugs and enable smooth cross-section movement
+ */
+export declare const customCollisionDetection: CollisionDetection;

package/features/form-management/components/FormBuilderView/FormBuilderView.d.ts

@@ -0,0 +1,17 @@
+import { FormWizardConfig } from '../../../../../../core/src/index.ts';
+import { default as React } from 'react';
+import { FormConfig } from '../../../../config/types';
+export interface FormBuilderViewProps {
+    projectId: string;
+    formId: string;
+    config?: FormConfig;
+    showPreview?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    onSave?: (config: FormWizardConfig) => Promise<void>;
+}
+/**
+ * Standalone FormBuilderView component
+ * Wraps FormBuilder with loading, error handling, and navigation
+ */
+export declare const FormBuilderView: React.FC<FormBuilderViewProps>;

package/features/form-management/components/FormExplorer/FormExplorer.d.ts

@@ -0,0 +1,38 @@
+import { FormWizardConfig } from '../../../../../../core/src/index.ts';
+import { FormConfig } from '../../../../config/types';
+import { ExplorerView } from '../FormExplorerCore/FormExplorerCore';
+export interface FormExplorerProps {
+    /**
+     * Optional form configuration
+     * If not provided, FormExplorer will automatically search for form.config.json in the user's project
+     * Supports both strict FormConfig and raw JSON objects (which will be processed)
+     */
+    config?: FormConfig | Record<string, unknown>;
+    initialView?: ExplorerView;
+    onFormSave?: (projectId: string, wizardId: string, config: FormWizardConfig) => Promise<void>;
+    onFormLoad?: (projectId: string, wizardId: string) => Promise<FormWizardConfig>;
+    onProjectCreate?: (projectName: string) => Promise<boolean>;
+    onFormCreate?: (projectId: string, formId: string, title: string) => Promise<FormWizardConfig | null>;
+    onFormDelete?: (projectId: string, wizardId: string) => Promise<boolean>;
+    onFormEdit?: (projectId: string, wizardId: string, config: FormWizardConfig) => void;
+    showPreview?: boolean;
+    getPreviewUrl?: (projectId: string, wizardId: string) => string;
+    className?: string;
+    style?: React.CSSProperties;
+}
+/**
+ * FormExplorer - Legacy form management wrapper with config auto-detection
+ *
+ * @deprecated Use standalone view components with NavigationProvider instead:
+ * - ProjectsView, FormsView, FormBuilderView
+ *
+ * @see ProjectsView
+ * @see FormsView
+ * @see FormBuilderView
+ */
+declare const FormExplorer: React.FC<FormExplorerProps>;
+/** @deprecated Use standalone view components instead */
+export default FormExplorer;
+/** @deprecated Use standalone view components instead */
+export { FormExplorer };
+export type { ExplorerView };

package/features/form-management/components/FormExplorerCore/FormExplorerCore.d.ts

@@ -0,0 +1,67 @@
+import { FormWizardConfig } from '../../../../../../core/src/index.ts';
+import { default as React } from 'react';
+import { FormConfig } from '../../../../config/types';
+import { ViewState } from '../../types/viewTypes';
+export type ExplorerView = ViewState;
+export interface FormExplorerCoreProps {
+    /**
+     * Optional form configuration
+     */
+    config?: FormConfig;
+    /**
+     * Optional initial view configuration
+     */
+    initialView?: ExplorerView;
+    /**
+     * Optional custom save handler for forms
+     */
+    onFormSave?: (projectId: string, wizardId: string, config: FormWizardConfig) => Promise<void>;
+    /**
+     * Optional custom load handler for forms
+     */
+    onFormLoad?: (projectId: string, wizardId: string) => Promise<FormWizardConfig>;
+    /**
+     * Optional custom form creation handler
+     */
+    onFormCreate?: (projectId: string, formId: string, title: string) => Promise<FormWizardConfig | null>;
+    /**
+     * Optional custom form deletion handler
+     */
+    onFormDelete?: (projectId: string, wizardId: string) => Promise<boolean>;
+    /**
+     * Optional form edit handler
+     */
+    onFormEdit?: (projectId: string, wizardId: string, config: FormWizardConfig) => void;
+    /**
+     * Whether to show preview functionality
+     */
+    showPreview?: boolean;
+    /**
+     * Custom preview URL generator
+     */
+    getPreviewUrl?: (projectId: string, wizardId: string) => string;
+    /**
+     * Custom navigation handler for going back from builder to forms list
+     * If not provided, will use internal navigateBack handler
+     */
+    onNavigateToForms?: (projectId: string) => void;
+    /**
+     * Custom navigation handler for going back to projects list
+     * If not provided, will use internal view state navigation
+     */
+    onNavigateToProjects?: () => void;
+    /**
+     * Whether to disable automatic route-based navigation
+     * @deprecated No longer has effect - route navigation removed
+     */
+    disableRouteNavigation?: boolean;
+    /**
+     * Additional CSS class name
+     */
+    className?: string;
+    /**
+     * Custom styles
+     */
+    style?: React.CSSProperties;
+}
+export declare const FormExplorerCore: React.FC<FormExplorerCoreProps>;

package/features/form-management/components/FormManager/FormManager.d.ts

@@ -0,0 +1,43 @@
+import { FormWizardConfig } from '../../../../../../core/src/index.ts';
+export interface RouterIntegration {
+    params: {
+        project?: string;
+        wizardId?: string;
+    };
+    navigate: (path: string) => void;
+    pathname: string;
+}
+type FormManagerView = {
+    type: "explorer";
+} | {
+    type: "editor";
+    projectId: string;
+    wizardId: string;
+    config: FormWizardConfig;
+};
+export interface FormManagerProps {
+    /** Optional CSS class name */
+    className?: string;
+    /** Optional custom styles */
+    style?: React.CSSProperties;
+    /** Optional initial view */
+    initialView?: FormManagerView;
+    /** Whether to show preview functionality */
+    showPreview?: boolean;
+    /** Custom preview URL generator */
+    getPreviewUrl?: (projectId: string, wizardId: string) => string;
+    /** Optional router integration for framework compatibility */
+    router?: RouterIntegration;
+    /** Optional configuration override */
+    config?: {
+        urls?: {
+            previewBase?: string;
+            previewPath?: string;
+        };
+    };
+    /** Alternative prop name for preview URL function (alias for getPreviewUrl) */
+    previewUrl?: (projectId: string, wizardId: string) => string;
+}
+declare const FormManager: React.FC<FormManagerProps>;
+export default FormManager;
+export type { FormManagerView };

package/features/form-management/components/FormSectionList/FormSectionList.d.ts

@@ -0,0 +1 @@
+export declare function FormSectionList(): import("react/jsx-runtime").JSX.Element | null;

package/features/form-management/components/FormsView/FormsView.d.ts

@@ -0,0 +1,40 @@
+/**
+ * FormsView with TanStack Query - Example implementation
+ * Demonstrates how to replace manual state management with TanStack Query
+ */
+export interface FormsViewProps {
+    projectId: string;
+    /** If provided, used instead of internal TanStack Query fetch */
+    forms?: {
+        id: string;
+        title: string;
+        fileName: string;
+        lastModified: number;
+        description?: string;
+    }[];
+    /** Project name override — used when forms prop is provided */
+    projectName?: string;
+    /** If provided, used instead of internal loading state */
+    isLoading?: boolean;
+    onNavigateToProjects?: () => void;
+    onRefresh?: () => void;
+    /** Custom form creation handler — bypasses the default formsExplorer storage path */
+    onCreateForm?: (request: {
+        projectId: string;
+        formId: string;
+        title: string;
+        description?: string;
+    }) => Promise<{
+        success: boolean;
+        formId?: string;
+    }>;
+    onFormDeleted?: (projectId: string, formId: string) => void;
+    onFormAdded?: (projectId: string, form: {
+        id: string;
+        title: string;
+        description?: string;
+    }) => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare const FormsView: React.FC<FormsViewProps>;

package/features/form-management/components/NewFormDialog/NewFormDialog.d.ts

@@ -0,0 +1,25 @@
+/**
+ * NewFormDialog component - dialog for creating new forms
+ */
+export interface NewFormDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    selectedProjectId?: string;
+    onFormCreated?: (projectId: string, formId: string) => void;
+    onFormAdded?: (projectId: string, form: {
+        id: string;
+        title: string;
+        description?: string;
+    }) => void;
+    /** Custom form creation handler — bypasses the default formsExplorer storage path */
+    onCreateForm?: (request: {
+        projectId: string;
+        formId: string;
+        title: string;
+        description?: string;
+    }) => Promise<{
+        success: boolean;
+        formId?: string;
+    }>;
+}
+export declare const NewFormDialog: React.FC<NewFormDialogProps>;

package/features/form-management/components/NewProjectDialog/NewProjectDialog.d.ts

@@ -0,0 +1,23 @@
+/**
+ * NewProjectDialog component - dialog for creating new projects
+ */
+export interface NewProjectDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onProjectCreated?: (projectData?: {
+        projectId: string;
+        name: string;
+        description?: string;
+    }) => void;
+    /** Custom project creation handler — bypasses the default formsExplorer storage path */
+    onCreateProject?: (request: {
+        name: string;
+        description?: string;
+    }) => Promise<{
+        success: boolean;
+        projectId?: string;
+        name?: string;
+        description?: string;
+    }>;
+}
+export declare const NewProjectDialog: React.FC<NewProjectDialogProps>;

package/features/form-management/components/ProjectCard/ProjectCard.d.ts

@@ -0,0 +1,9 @@
+import { ProjectMetadata } from '../../../../../../core/src/index.ts';
+export interface ProjectCardProps {
+    project: ProjectMetadata;
+    onCreateForm: () => void;
+    onEditForm: (projectId: string, wizardId: string) => void;
+    onDeleteForm: (projectId: string, wizardId: string) => void;
+    onPreviewForm?: (projectId: string, wizardId: string) => void;
+}
+export declare const ProjectCard: React.FC<ProjectCardProps>;

package/features/form-management/components/ProjectsView/ProjectsView.d.ts

@@ -0,0 +1,20 @@
+import { ProjectMetadata } from '../../../../../../core/src/index.ts';
+export interface ProjectsViewProps {
+    projects?: ProjectMetadata[];
+    isLoading?: boolean;
+    onRefresh?: () => void;
+    onProjectDeleted?: (projectId: string) => void;
+    /** Custom project creation handler — bypasses the default formsExplorer storage path */
+    onCreateProject?: (request: {
+        name: string;
+        description?: string;
+    }) => Promise<{
+        success: boolean;
+        projectId?: string;
+        name?: string;
+        description?: string;
+    }>;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare const ProjectsView: React.FC<ProjectsViewProps>;

package/features/form-management/components/SearchInput/SearchInput.d.ts

@@ -0,0 +1,9 @@
+/**
+ * SearchInput - Reusable search input component for views
+ */
+export interface SearchInputProps {
+    placeholder?: string;
+    onSearchChange: (query: string) => void;
+    className?: string;
+}
+export declare const SearchInput: React.FC<SearchInputProps>;

package/features/form-management/components/ViewCard/ViewCard.d.ts

@@ -0,0 +1,40 @@
+import { ButtonProps } from '../../../../../../ui/src/design-system/index.ts';
+import { ReactNode } from 'react';
+export interface ViewCardMetaData {
+    label: string;
+    value: string | number;
+}
+export interface ViewCardAction {
+    label?: string;
+    icon?: ReactNode;
+    onClick: () => void;
+    appearance?: ButtonProps["appearance"];
+    className?: string;
+}
+export interface ViewCardDropdownAction {
+    label?: string;
+    icon?: ReactNode;
+    onClick: () => void;
+    variant?: "default" | "destructive";
+    className?: string;
+    disabled?: boolean;
+}
+export interface ViewCardProps {
+    /** Icon to display next to the title */
+    icon: ReactNode;
+    /** Main title of the card */
+    title: string;
+    /** Optional description text */
+    description?: string;
+    /** Array of metadata items to display */
+    metadata?: ViewCardMetaData[];
+    /** Dropdown menu actions (appears in top-right) */
+    dropdownActions?: ViewCardDropdownAction[];
+    /** Primary action button (appears at bottom) */
+    primaryAction?: ViewCardAction;
+    /** Additional CSS classes */
+    className?: string;
+    /** Click handler for the entire card */
+    onClick?: () => void;
+}
+export declare const ViewCard: React.FC<ViewCardProps>;

package/features/form-management/components/pages/FormBuilderPage.d.ts

@@ -0,0 +1,3 @@
+/** @deprecated Import from integrations/react-router instead */
+export type { FormBuilderPageProps } from '../../../../integrations/react-router/FormBuilderPage/FormBuilderPage';
+export { FormBuilderPage } from '../../../../integrations/react-router/FormBuilderPage/FormBuilderPage';

package/features/form-management/components/pages/FormsPage.d.ts

@@ -0,0 +1,3 @@
+/** @deprecated Import from integrations/react-router instead */
+export type { FormsPageProps } from '../../../../integrations/react-router/FormsPage';
+export { FormsPage } from '../../../../integrations/react-router/FormsPage';