@digiform/builder 0.1.7 → 0.2.1

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

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+export interface ProjectsPageProps {
+    /**
+     * Optional CSS class name
+     */
+    className?: string;
+    /**
+     * Optional inline styles
+     */
+    style?: React.CSSProperties;
+}
+/**
+ * Standalone ProjectsPage component for user-defined routing
+ * Shows the projects overview and allows navigation to forms
+ */
+export declare const ProjectsPage: React.FC<ProjectsPageProps>;

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

@@ -0,0 +1,13 @@
+/**
+ * Page components for user-defined routing
+ */
+/** @deprecated Import from integrations/react-router instead */
+export type { FormBuilderPageProps } from './FormBuilderPage';
+/** @deprecated Import from integrations/react-router instead */
+export { FormBuilderPage } from './FormBuilderPage';
+/** @deprecated Import from integrations/react-router instead */
+export type { FormsPageProps } from './FormsPage';
+/** @deprecated Import from integrations/react-router instead */
+export { FormsPage } from './FormsPage';
+export type { ProjectsPageProps } from './ProjectsPage';
+export { ProjectsPage } from './ProjectsPage';

package/features/form-management/hooks/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Form Management Hooks
+ */
+export type { UseFormExplorerStateOptions, UseFormExplorerStateReturn, } from './useFormExplorerState';
+export { useFormExplorerState } from './useFormExplorerState';
+export type { UseFormOperationsOptions, UseFormOperationsReturn, } from './useFormOperations';
+export { useFormOperations } from './useFormOperations';
+export type { UseProjectOperationsOptions, UseProjectOperationsReturn, } from './useProjectOperations';
+export { useProjectOperations } from './useProjectOperations';

package/features/form-management/hooks/useFormActions.d.ts

@@ -0,0 +1,20 @@
+import { CreateFormRequest } from '../../../../../core/src/index.ts';
+export interface UseFormActionsReturn {
+    /**
+     * Create a new form in a project
+     */
+    createForm: (request: CreateFormRequest) => Promise<boolean>;
+    /**
+     * Delete a specific form from a project
+     */
+    deleteForm: (projectId: string, formId: string) => Promise<boolean>;
+    /**
+     * Edit a form (navigation helper)
+     */
+    editForm: (projectId: string, formId: string) => void;
+}
+/**
+ * Hook providing centralized form operations
+ * Uses the storage layer directly to avoid prop drilling
+ */
+export declare function useFormActions(): UseFormActionsReturn;

package/features/form-management/hooks/useFormData.d.ts

@@ -0,0 +1,13 @@
+import { FormWizardConfig } from '../../../../../core/src/index.ts';
+import { FormConfig } from '../../../config/types';
+interface UseFormDataOptions {
+    projectId: string;
+    formId: string;
+    config?: FormConfig;
+}
+/**
+ * Query hook for loading a single form configuration
+ * Returns form config with loading and error states
+ */
+export declare function useFormData({ projectId, formId, config }: UseFormDataOptions): import('@tanstack/react-query').UseQueryResult<FormWizardConfig, Error>;
+export {};

package/features/form-management/hooks/useFormExplorerState.d.ts

@@ -0,0 +1,26 @@
+import { FormsExplorerState } from '../../../../../core/src/index.ts';
+import { FormConfig } from '../../../config/types';
+export interface UseFormExplorerStateOptions {
+    autoLoad?: boolean;
+    config?: FormConfig;
+}
+export interface UseFormExplorerStateReturn {
+    state: FormsExplorerState;
+    searchQuery: string;
+    setSearchQuery: (query: string) => void;
+    filteredProjects: FormsExplorerState["projects"];
+    loadProjects: () => Promise<void>;
+    selectedProject: string | null;
+    setSelectedProject: (projectId: string | null) => void;
+    addProjectOptimistic: (project: Omit<FormsExplorerState["projects"][0], "lastModified">) => void;
+    removeProjectOptimistic: (projectId: string) => void;
+    addFormOptimistic: (projectId: string, form: {
+        id: string;
+        title: string;
+        description?: string;
+    }) => void;
+    removeFormOptimistic: (projectId: string, formId: string) => void;
+    refreshProjectsList: () => Promise<void>;
+    invalidateCache: () => void;
+}
+export declare function useFormExplorerState({ autoLoad, config, }?: UseFormExplorerStateOptions): UseFormExplorerStateReturn;

package/features/form-management/hooks/useFormOperations.d.ts

@@ -0,0 +1,17 @@
+import { FormWizardConfig } from '../../../../../core/src/index.ts';
+export interface UseFormOperationsOptions {
+    onFormLoad?: (projectId: string, wizardId: string) => Promise<FormWizardConfig>;
+    onFormCreate?: (projectId: string, formId: string, title: string) => Promise<FormWizardConfig | null>;
+    onFormDelete?: (projectId: string, wizardId: string) => Promise<boolean>;
+    onFormSave?: (projectId: string, wizardId: string, config: FormWizardConfig) => Promise<void>;
+    onFormEdit?: (projectId: string, wizardId: string, config: FormWizardConfig) => void;
+    onFormCreated?: (projectId: string, wizardId: string, config: FormWizardConfig) => void;
+    onProjectsRefresh?: () => Promise<void>;
+}
+export interface UseFormOperationsReturn {
+    handleCreateForm: (projectId: string, formTitle: string, formId?: string) => Promise<FormWizardConfig | null>;
+    handleDeleteForm: (projectId: string, wizardId: string) => Promise<boolean>;
+    handleEditForm: (projectId: string, wizardId: string) => Promise<void>;
+    handleSaveForm: (projectId: string, wizardId: string, config: FormWizardConfig) => Promise<void>;
+}
+export declare function useFormOperations({ onFormLoad, onFormCreate, onFormDelete, onFormSave, onFormEdit, onFormCreated, onProjectsRefresh, }?: UseFormOperationsOptions): UseFormOperationsReturn;

package/features/form-management/hooks/useFormsQuery.d.ts

@@ -0,0 +1,50 @@
+import { FormConfig } from '../../../config/types';
+export declare const formsQueryKeys: {
+    all: readonly ["forms"];
+    projects: () => readonly ["forms", "projects"];
+    project: (projectId: string) => readonly ["forms", "projects", string];
+    form: (projectId: string, formId: string) => readonly ["forms", "projects", string, string];
+};
+interface UseFormsQueryOptions {
+    config?: FormConfig;
+}
+/**
+ * Query hook for fetching all projects and forms
+ * Replaces useFormExplorerState with automatic caching and background updates
+ */
+export declare function useFormsQuery({ config }?: UseFormsQueryOptions): import('@tanstack/react-query').UseQueryResult<import('../../../../../core/src/index.ts').ProjectMetadata[], Error>;
+/**
+ * Mutation hook for creating forms with optimistic updates
+ */
+export declare function useCreateFormMutation(): import('@tanstack/react-query').UseMutationResult<{
+    config: import('../../../../../core/src/index.ts').FormWizardConfig;
+    projectId: string;
+    formId: string;
+    title: string;
+    description?: string;
+}, Error, {
+    projectId: string;
+    formId: string;
+    title: string;
+    description?: string;
+}, {
+    previousProjects: unknown;
+}>;
+/**
+ * Mutation hook for deleting forms with optimistic updates
+ */
+export declare function useDeleteFormMutation(): import('@tanstack/react-query').UseMutationResult<{
+    projectId: string;
+    formId: string;
+}, Error, {
+    projectId: string;
+    formId: string;
+}, {
+    previousProjects: unknown;
+}>;
+/**
+ * Hook to force refresh all form data
+ * Useful for manual sync when needed
+ */
+export declare function useRefreshForms(): () => void;
+export {};

package/features/form-management/hooks/useProjectActions.d.ts

@@ -0,0 +1,25 @@
+import { CreateProjectRequest } from '../../../../../core/src/index.ts';
+export interface UseProjectActionsReturn {
+    /**
+     * Create a new project
+     */
+    createProject: (request: CreateProjectRequest) => Promise<boolean>;
+    /**
+     * Delete a project by deleting all its forms
+     * Note: Some storage providers may have direct project deletion methods
+     */
+    deleteProject: (projectId: string) => Promise<boolean>;
+    /**
+     * Delete a specific form from a project
+     */
+    deleteForm: (projectId: string, formId: string) => Promise<boolean>;
+    /**
+     * Navigate to a project's forms view (navigation helper)
+     */
+    navigateToProject: (projectId: string) => void;
+}
+/**
+ * Hook providing centralized project and form operations
+ * Uses the storage layer directly to avoid prop drilling
+ */
+export declare function useProjectActions(): UseProjectActionsReturn;

package/features/form-management/hooks/useProjectOperations.d.ts

@@ -0,0 +1,10 @@
+/**
+ * useProjectOperations - Hook for project operations
+ */
+export interface UseProjectOperationsOptions {
+    onProjectsRefresh?: () => Promise<void>;
+}
+export interface UseProjectOperationsReturn {
+    handleCreateProject: (projectName: string, description?: string) => Promise<boolean>;
+}
+export declare function useProjectOperations({ onProjectsRefresh, }?: UseProjectOperationsOptions): UseProjectOperationsReturn;

package/features/form-management/hooks/useProjectsData.d.ts

@@ -0,0 +1,13 @@
+import { FormConfig } from '../../../config/types';
+export declare const projectsQueryKeys: {
+    all: readonly ["projects"];
+};
+interface UseProjectsDataOptions {
+    config?: FormConfig;
+}
+/**
+ * Query hook for fetching all projects
+ * Provides automatic caching and background updates via TanStack Query
+ */
+export declare function useProjectsData({ config }?: UseProjectsDataOptions): import('@tanstack/react-query').UseQueryResult<import('../../../../../core/src/index.ts').ProjectMetadata[], Error>;
+export {};

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

@@ -0,0 +1,29 @@
+/**
+ * Form Management Feature
+ * Handles form and project CRUD operations
+ */
+/** FormBuilderView - Standalone form builder component */
+export type { FormBuilderViewProps } from './components/FormBuilderView/FormBuilderView';
+export { FormBuilderView } from './components/FormBuilderView/FormBuilderView';
+/** FormsView - Standalone forms list component */
+export type { FormsViewProps } from './components/FormsView/FormsView';
+export { FormsView } from './components/FormsView/FormsView';
+/** ProjectsView - Standalone projects list component */
+export type { ProjectsViewProps } from './components/ProjectsView/ProjectsView';
+export { ProjectsView } from './components/ProjectsView/ProjectsView';
+export { useFormData } from './hooks/useFormData';
+export { useProjectsData } from './hooks/useProjectsData';
+export type { NewFormDialogProps } from './components/NewFormDialog/NewFormDialog';
+export { NewFormDialog } from './components/NewFormDialog/NewFormDialog';
+export type { NewProjectDialogProps } from './components/NewProjectDialog/NewProjectDialog';
+export { NewProjectDialog } from './components/NewProjectDialog/NewProjectDialog';
+export type { ProjectCardProps } from './components/ProjectCard/ProjectCard';
+export { ProjectCard } from './components/ProjectCard/ProjectCard';
+export type { UseFormExplorerStateOptions, UseFormExplorerStateReturn, UseFormOperationsOptions, UseFormOperationsReturn, UseProjectOperationsOptions, UseProjectOperationsReturn, } from './hooks';
+export { useFormExplorerState, useFormOperations, useProjectOperations, } from './hooks';
+/** @deprecated Since v1.2 - Use standalone view components with NavigationProvider */
+export type { FormExplorerCoreProps } from './components/FormExplorerCore/FormExplorerCore';
+/** @deprecated Since v1.2 - Use standalone view components with NavigationProvider */
+export { FormExplorerCore } from './components/FormExplorerCore/FormExplorerCore';
+/** @deprecated SPA view state types - not needed for standalone components */
+export type { ExplorerViewType, NavigationContext, ViewState, } from './types/viewTypes';

package/features/form-management/layout/BaseHeader/BaseHeader.d.ts

@@ -0,0 +1 @@
+export declare const BaseHeader: () => import("react/jsx-runtime").JSX.Element;

package/features/form-management/layout/BaseLayout/BaseLayout.d.ts

@@ -0,0 +1,25 @@
+import { ButtonProps } from '../../../../../../ui/src/design-system/index.ts';
+import { ReactNode } from 'react';
+export interface BaseLayoutProps {
+    title: string;
+    subtitle?: string;
+    showBackButton?: boolean;
+    onBack?: () => void;
+    backButtonText?: string;
+    searchSlot?: ReactNode;
+    primaryAction?: {
+        label: string;
+        onClick: () => void;
+        icon?: ReactNode;
+    };
+    secondaryActions?: Array<{
+        label: string;
+        onClick: () => void;
+        icon?: ReactNode;
+        variant?: ButtonProps["appearance"];
+    }>;
+    isLoading?: boolean;
+    children: ReactNode;
+    className?: string;
+}
+export declare const BaseLayout: React.FC<BaseLayoutProps>;

package/features/form-management/providers/QueryProvider.d.ts

@@ -0,0 +1,8 @@
+import { QueryClient } from '@tanstack/react-query';
+import { default as React } from 'react';
+declare const queryClient: QueryClient;
+interface QueryProviderProps {
+    children: React.ReactNode;
+}
+export declare function QueryProvider({ children }: QueryProviderProps): import("react/jsx-runtime").JSX.Element;
+export { queryClient };

package/features/form-management/types/viewTypes.d.ts

@@ -0,0 +1,53 @@
+/**
+ * View types for the SPA-style FormExplorer navigation
+ *
+ * @deprecated These types support the legacy FormExplorerCore SPA architecture.
+ * Standalone components (ProjectsView, FormsView, FormBuilderView) do not need these types.
+ */
+/** @deprecated Use standalone view components instead */
+export type ExplorerViewType = "projects" | "forms" | "builder" | "preview";
+/** @deprecated Use standalone view components instead */
+export interface BaseViewState {
+    type: ExplorerViewType;
+}
+/** @deprecated Use standalone view components instead */
+export interface ProjectsViewState extends BaseViewState {
+    type: "projects";
+}
+/** @deprecated Use standalone view components instead */
+export interface FormsViewState extends BaseViewState {
+    type: "forms";
+    projectId: string;
+    projectName: string;
+}
+/** @deprecated Use standalone view components instead */
+export interface BuilderViewState extends BaseViewState {
+    type: "builder";
+    projectId: string;
+    formId: string;
+    config?: unknown;
+}
+/** @deprecated Use standalone view components instead */
+export interface PreviewViewState extends BaseViewState {
+    type: "preview";
+    projectId: string;
+    formId: string;
+}
+/** @deprecated Use standalone view components instead */
+export type ViewState = ProjectsViewState | FormsViewState | BuilderViewState | PreviewViewState;
+/** @deprecated Use standalone view components instead */
+export interface NavigationContext {
+    currentView: ViewState;
+    viewHistory: ViewState[];
+    navigateToView: (view: ViewState, addToHistory?: boolean) => void;
+    navigateBack: () => void;
+    canGoBack: boolean;
+}
+/** @deprecated Use standalone view components instead */
+export declare const createProjectsView: () => ProjectsViewState;
+/** @deprecated Use standalone view components instead */
+export declare const createFormsView: (projectId: string, projectName: string) => FormsViewState;
+/** @deprecated Use standalone view components instead */
+export declare const createBuilderView: (projectId: string, formId: string, config?: unknown) => BuilderViewState;
+/** @deprecated Use standalone view components instead */
+export declare const createPreviewView: (projectId: string, formId: string) => PreviewViewState;

package/features/form-management/utils/configInitializer.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Configuration initializer - stub implementation
+ */
+export declare const initializeFormConfiguration: () => Promise<void>;

package/features/index.d.ts

@@ -0,0 +1,9 @@
+export * from './condition-editor';
+export * from './dialog-system';
+export * from './form-builder';
+export { CanvasComponent, FormBuilder } from './form-builder';
+export * from './form-management';
+export * from './property-editors';
+export * from './template-system';
+export * from './trigger-action-system';
+export * from './visual-mapping';

package/features/property-editors/components/ComponentValidationEditor/ComponentValidationEditor.d.ts

@@ -0,0 +1,12 @@
+import { ComponentConfig, ComponentValidation } from '../../../../../../core/src/index.ts';
+import { default as React } from 'react';
+interface ComponentValidationEditorProps {
+    component: ComponentConfig;
+    onChange: (validation: ComponentValidation | undefined) => void;
+    fieldId: string;
+}
+/**
+ * Component validation editor that bridges the admin and user validation systems
+ */
+export declare const ComponentValidationEditor: React.FC<ComponentValidationEditorProps>;
+export {};

package/features/property-editors/components/GenericPropertyEditor/GenericPropertyEditor.d.ts

@@ -0,0 +1,13 @@
+import { ComponentValue } from '../../../../component-registry/types';
+import { ComponentConfig } from '../../../../../../core/src/index.ts';
+import { PropertyEditorSchema } from '../../types/schema';
+interface GenericPropertyEditorProps {
+    component: ComponentConfig;
+    stepId: string;
+    handlePropertyChange: (field: string, value: ComponentValue) => void;
+    handleChange: (field: string, value: ComponentValue) => void;
+    schema: PropertyEditorSchema;
+    disabled?: boolean;
+}
+export declare const GenericPropertyEditor: React.FC<GenericPropertyEditorProps>;
+export default GenericPropertyEditor;

package/features/property-editors/components/ProgressLoaderEditor/ProgressLoaderEditor.d.ts

@@ -0,0 +1,12 @@
+import { ProgressLoaderConfig } from '../../../../../../ui/src/index.ts';
+interface ProgressLoaderEditorProps {
+    config: Partial<ProgressLoaderConfig>;
+    onConfigUpdate: (updates: Partial<ProgressLoaderConfig>) => void;
+    availableComponents?: Array<{
+        id: string;
+        label: string;
+    }>;
+    className?: string;
+}
+export declare const ProgressLoaderEditor: import('react').NamedExoticComponent<ProgressLoaderEditorProps>;
+export {};

package/features/property-editors/components/RadioGroupEditor/RadioGroupEditor.d.ts

@@ -0,0 +1,3 @@
+import { PropertyEditorProps } from '../../types/types';
+export declare const RadioGroupEditor: React.FC<PropertyEditorProps>;
+export default RadioGroupEditor;

package/features/property-editors/components/SelectEditor/SelectEditor.d.ts

@@ -0,0 +1,3 @@
+import { PropertyEditorProps } from '../../types/schema';
+export declare const SelectEditor: React.FC<PropertyEditorProps>;
+export default SelectEditor;

package/features/property-editors/components/ValidationRuleEditor/ValidationRuleEditor.d.ts

@@ -0,0 +1,23 @@
+import { ComponentValidationConfig, ValidationRuleParameter } from '../../../../component-registry/validation';
+import { ComponentConfig } from '../../../../../../core/src/index.ts';
+import { default as React } from 'react';
+interface ValidationParameterInputProps {
+    parameter: ValidationRuleParameter;
+    value: string | number | boolean;
+    onChange: (value: string | number | boolean) => void;
+    fieldId: string;
+}
+/**
+ * Input component for a single validation rule parameter
+ */
+export declare const ValidationParameterInput: React.FC<ValidationParameterInputProps>;
+interface ValidationRulesConfiguratorProps {
+    component: ComponentConfig;
+    value: ComponentValidationConfig | undefined;
+    onChange: (config: ComponentValidationConfig) => void;
+}
+/**
+ * Complete validation rules configuration interface
+ */
+export declare const ValidationRulesConfigurator: React.FC<ValidationRulesConfiguratorProps>;
+export {};

package/features/property-editors/components/ValidationRuleListItem/ValidationRuleListItem.d.ts

@@ -0,0 +1,9 @@
+import { ValidationRuleDefinition, ValidationRuleInstance } from '../../../../component-registry/validation';
+interface ValidationRuleListItemProps {
+    rule: ValidationRuleInstance;
+    ruleDefinition: ValidationRuleDefinition;
+    onEdit: () => void;
+    onDelete: () => void;
+}
+declare const ValidationRuleListItem: import('react').NamedExoticComponent<ValidationRuleListItemProps>;
+export { ValidationRuleListItem };

package/features/property-editors/components/ValidationRuleSheet/ValidationRuleSheet.d.ts

@@ -0,0 +1,14 @@
+import { ValidationRuleDefinition, ValidationRuleInstance } from '../../../../component-registry/validation';
+interface ValidationRuleSheetProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    availableRuleTypes: ValidationRuleDefinition[];
+    editingRule?: {
+        rule: ValidationRuleInstance;
+        index: number;
+    } | null;
+    onRuleCreate?: (rule: ValidationRuleInstance) => void;
+    onRuleUpdate?: (index: number, rule: ValidationRuleInstance) => void;
+}
+declare const ValidationRuleSheet: import('react').NamedExoticComponent<ValidationRuleSheetProps>;
+export { ValidationRuleSheet };

package/features/property-editors/index.d.ts

@@ -0,0 +1,5 @@
+export { GenericPropertyEditor } from './components/GenericPropertyEditor/GenericPropertyEditor';
+export { ProgressLoaderEditor } from './components/ProgressLoaderEditor/ProgressLoaderEditor';
+export { default as RadioGroupEditor } from './components/RadioGroupEditor/RadioGroupEditor';
+export { default as SelectEditor } from './components/SelectEditor/SelectEditor';
+export * from './types/schema';

package/features/property-editors/types/schema.d.ts

@@ -0,0 +1,66 @@
+import { ComponentValue } from '../../../component-registry/types';
+import { ComponentConfig } from '../../../../../core/src/index.ts';
+export type PropertyFieldType = "text" | "textarea" | "select" | "checkbox" | "number" | "email" | "url" | "validationRules" | "valueChangeActions" | "triggers" | "conditions";
+export interface SelectOption {
+    label: string;
+    value: string;
+    description?: string;
+}
+export interface PropertyFieldBase {
+    type: PropertyFieldType;
+    label: string;
+    description?: string;
+    defaultValue?: ComponentValue;
+    required?: boolean;
+    tab?: "general" | "advanced" | "validation" | "triggers" | "conditions" | "styling";
+    condition?: (component: ComponentConfig) => boolean;
+}
+export interface TextFieldSchema extends PropertyFieldBase {
+    type: "text" | "email" | "url";
+    placeholder?: string;
+    maxLength?: number;
+}
+export interface TextareaFieldSchema extends PropertyFieldBase {
+    type: "textarea";
+    placeholder?: string;
+    rows?: number;
+}
+export interface SelectFieldSchema extends PropertyFieldBase {
+    type: "select";
+    options: SelectOption[];
+    placeholder?: string;
+}
+export interface CheckboxFieldSchema extends PropertyFieldBase {
+    type: "checkbox";
+}
+export interface NumberFieldSchema extends PropertyFieldBase {
+    type: "number";
+    min?: number;
+    max?: number;
+    step?: number;
+    placeholder?: string;
+}
+export interface ValidationRulesFieldSchema extends PropertyFieldBase {
+    type: "validationRules";
+}
+export interface ValueChangeActionsFieldSchema extends PropertyFieldBase {
+    type: "valueChangeActions";
+}
+export interface TriggersFieldSchema extends PropertyFieldBase {
+    type: "triggers";
+}
+export interface ConditionsFieldSchema extends PropertyFieldBase {
+    type: "conditions";
+}
+export type PropertyFieldSchema = TextFieldSchema | TextareaFieldSchema | SelectFieldSchema | CheckboxFieldSchema | NumberFieldSchema | ValidationRulesFieldSchema | ValueChangeActionsFieldSchema | TriggersFieldSchema | ConditionsFieldSchema;
+export interface PropertyEditorSchema {
+    component: Record<string, PropertyFieldSchema>;
+    properties: Record<string, PropertyFieldSchema>;
+}
+export interface PropertyEditorProps {
+    component: ComponentConfig;
+    stepId: string;
+    handlePropertyChange: (field: string, value: ComponentValue) => void;
+    handleChange: (field: string, value: ComponentValue) => void;
+    disabled?: boolean;
+}

package/features/property-editors/types/types.d.ts

@@ -0,0 +1,23 @@
+import { ComponentConfig } from '../../../../../core/src/index.ts';
+import { ComponentValue } from '../../../component-registry/types';
+export interface PropertyEditorProps {
+    component: ComponentConfig;
+    stepId: string;
+    handlePropertyChange: (field: string, value: ComponentValue) => void;
+    handleChange: (field: string, value: ComponentValue) => void;
+}
+export interface PropertyFieldConfig {
+    type: "text" | "textarea" | "select" | "checkbox" | "number";
+    label: string;
+    field: string;
+    placeholder?: string;
+    options?: Array<{
+        label: string;
+        value: string;
+    }>;
+    rows?: number;
+    defaultValue?: string;
+    isComponentProperty?: boolean;
+    condition?: (component: ComponentConfig) => boolean;
+    className?: string;
+}

package/features/template-system/components/CreateTemplateDialog/CreateTemplateDialog.d.ts

@@ -0,0 +1,17 @@
+import { TemplateCategory } from '../../../../utils/fileStorage';
+import { FormStepConfig } from '../../../../../../core/src/index.ts';
+interface CreateTemplateDialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    steps: FormStepConfig[];
+    preSelectedStepId?: string | null;
+    onCreateTemplate: (templateData: {
+        name: string;
+        description: string;
+        category: TemplateCategory;
+        tags: string[];
+        stepsData: FormStepConfig[];
+    }) => Promise<void>;
+}
+export declare const CreateTemplateDialog: React.FC<CreateTemplateDialogProps>;
+export {};

package/features/template-system/components/DeleteTemplateDialog/DeleteTemplateDialog.d.ts

@@ -0,0 +1,11 @@
+import { Template, TemplateStorageConfig } from '../../../../utils/fileStorage';
+interface DeleteTemplateDialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    template: Template | null;
+    storageConfig: TemplateStorageConfig | null;
+    currentUser: string;
+    onTemplateDeleted: (templateId: string) => void;
+}
+export declare const DeleteTemplateDialog: React.FC<DeleteTemplateDialogProps>;
+export {};

package/features/template-system/components/DuplicateTemplateDialog/DuplicateTemplateDialog.d.ts

@@ -0,0 +1,11 @@
+import { Template, TemplateCategory, TemplateStorageConfig } from '../../../../utils/fileStorage';
+interface DuplicateTemplateDialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    template: Template | null;
+    storageConfig: TemplateStorageConfig | null;
+    currentUser: string;
+    onTemplateDuplicated: (templateId: string, category: TemplateCategory) => void;
+}
+export declare const DuplicateTemplateDialog: React.FC<DuplicateTemplateDialogProps>;
+export {};

package/features/template-system/components/EditTemplateDialog/EditTemplateDialog.d.ts

@@ -0,0 +1,10 @@
+import { Template, TemplateStorageConfig } from '../../../../utils/fileStorage';
+interface EditTemplateDialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    template: Template | null;
+    storageConfig: TemplateStorageConfig | null;
+    onTemplateUpdated: (updatedTemplate: Template) => void;
+}
+export declare const EditTemplateDialog: React.FC<EditTemplateDialogProps>;
+export {};

package/features/template-system/components/EnhancedTemplateBrowser/EnhancedTemplateBrowser.d.ts

@@ -0,0 +1,11 @@
+import { StepTemplate } from '../../../../store';
+import { TemplateCategory } from '../../../../utils/fileStorage';
+interface EnhancedTemplateBrowserProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onSelectTemplate: (templateKey: StepTemplate) => void;
+    onSelectCustomTemplate?: (templateId: string, category: TemplateCategory) => void;
+    currentUser?: string;
+}
+export declare const EnhancedTemplateBrowser: React.FC<EnhancedTemplateBrowserProps>;
+export {};