@digiform/wizard 0.1.7 → 0.2.1

package/FormWizard.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Form Wizard Component - Legacy export file for backward compatibility
+ *
+ * This file maintains backward compatibility for existing imports.
+ * New code should import from the features directory structure.
+ */
+export * from '../../core/src/index.ts';
+export * from '../../ui/src/index.ts';
+export * from './features/form-runtime';
+export { FormWizard as default } from './features/form-runtime';

package/features/api-integration/components/EnhancedActionExecutor/EnhancedActionExecutor.d.ts

@@ -0,0 +1,23 @@
+import { ActionTrigger, DialogConfig, FormAction, FormData, NavigationConfig } from '../../../../../../core/src/index.ts';
+interface ActionExecutorProps {
+    actions: FormAction[];
+    trigger: ActionTrigger;
+    formData: FormData;
+    onComplete: (results: Record<string, unknown>) => void;
+    onError: (error: Error) => void;
+    onFieldUpdate: (fieldPath: string, value: unknown) => void;
+    onShowDialog: (dialogConfig: DialogConfig) => void;
+    onNavigate: (navigationConfig: NavigationConfig) => void;
+    machineRef?: {
+        send: (event: {
+            type: string;
+            [key: string]: unknown;
+        }) => void;
+    };
+}
+/**
+ * Enhanced ActionExecutor that uses React Query for better API state management
+ */
+declare const EnhancedActionExecutor: import('react').NamedExoticComponent<ActionExecutorProps>;
+export { EnhancedActionExecutor };
+export default EnhancedActionExecutor;

package/features/api-integration/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * API Integration Feature
+ *
+ * Services for API calls and external integrations
+ */
+export { default as ActionExecutor } from './services/ActionExecutor';
+export { default as ApiCallExecutor } from './services/ApiCallExecutor';
+export { default as ApiCallService } from './services/ApiCallService';
+export { default as DialogExecutor } from './services/DialogExecutor';
+export { default as EnhancedActionExecutor } from './components/EnhancedActionExecutor/EnhancedActionExecutor';
+export { default as GenericTriggerService } from './services/GenericTriggerService';
+export { default as NavigationExecutor } from './services/NavigationExecutor';

package/features/api-integration/services/ActionExecutor.d.ts

@@ -0,0 +1,18 @@
+import { FormMachineEvents } from '../../state-management';
+import { ActionTrigger, DialogConfig, FormAction, FormData, NavigationConfig } from '../../../../../core/src/index.ts';
+interface ActionExecutorProps {
+    actions: FormAction[];
+    trigger: ActionTrigger;
+    formData: FormData;
+    onComplete: (results: Record<string, unknown>) => void;
+    onError: (error: Error) => void;
+    onFieldUpdate: (fieldPath: string, value: unknown) => void;
+    onShowDialog: (dialogConfig: DialogConfig) => void;
+    onNavigate: (navigationConfig: NavigationConfig) => void;
+    machineRef?: {
+        send: (event: FormMachineEvents) => void;
+    };
+}
+declare const ActionExecutor: import('react').NamedExoticComponent<ActionExecutorProps>;
+export { ActionExecutor };
+export default ActionExecutor;

package/features/api-integration/services/ApiCallExecutor.d.ts

@@ -0,0 +1,2 @@
+export declare const ApiCallExecutor: () => null;
+export default ApiCallExecutor;

package/features/api-integration/services/ApiCallService.d.ts

@@ -0,0 +1,40 @@
+import { ApiCallConfig, FormData } from '../../../../../core/src/index.ts';
+interface ApiCallServiceOptions {
+    onFieldUpdate?: (fieldPath: string, value: unknown) => void;
+}
+export declare class ApiCallService {
+    private options;
+    constructor(options?: ApiCallServiceOptions);
+    generateCacheKey(config: ApiCallConfig, formData: FormData): string;
+    createQueryOptions(config: ApiCallConfig, formData: FormData): {
+        queryKey: string[];
+        queryFn: () => Promise<unknown>;
+        gcTime: number;
+        staleTime: number;
+        retry: number;
+        throwOnError: boolean;
+    };
+    executeApiCall(config: ApiCallConfig, formData: FormData): Promise<unknown>;
+    private makeApiCall;
+    /**
+     * Detects if an error is likely a CORS error
+     */
+    private isCorsError;
+    /**
+     * Detects if an error is a network-related error (but not CORS)
+     */
+    private isNetworkError;
+    private applyFlattenedResponseMappings;
+    /**
+     * Extract the actual field name from a template string
+     * E.g., "${step-1.username}" -> "username"
+     */
+    private extractFieldNameFromTemplate;
+    private getValueFromPath;
+    private buildHeaders;
+    private buildQueryParams;
+    private interpolateTemplate;
+}
+export declare function useApiCall(config: ApiCallConfig, formData: FormData, options?: ApiCallServiceOptions): import('@tanstack/react-query').UseQueryResult<unknown, Error>;
+export declare function useApiMutation(config: ApiCallConfig, options?: ApiCallServiceOptions): import('@tanstack/react-query').UseMutationResult<unknown, Error, FormData, unknown>;
+export default ApiCallService;

package/features/api-integration/services/DialogExecutor.d.ts

@@ -0,0 +1,2 @@
+export declare const DialogExecutor: () => null;
+export default DialogExecutor;

package/features/api-integration/services/GenericTriggerService.d.ts

@@ -0,0 +1,118 @@
+import { FormWizardConfig } from '../../../../../core/src/index.ts';
+import { ExtendedTriggerActionContainer, ExtendedTriggerType } from '../../trigger-action-system/utils/triggerActionSystem';
+interface FormMachineContext {
+    data: Record<string, unknown>;
+    errors: Record<string, string[]>;
+    [key: string]: unknown;
+}
+interface FormMachineSnapshot {
+    context: FormMachineContext;
+}
+interface FormMachine {
+    send(event: FormMachineEvent): void;
+    getSnapshot(): FormMachineSnapshot;
+}
+type FormMachineEvent = {
+    type: "GO_TO_STEP";
+    stepId: string;
+    behavior?: "replace" | "push";
+} | {
+    type: "NEXT";
+    skipValidation?: boolean;
+} | {
+    type: "PREVIOUS";
+    skipValidation?: boolean;
+} | {
+    type: "SHOW_COMPONENT_ALERT";
+    componentId: string;
+    alert: ComponentAlert;
+} | {
+    type: "SHOW_ACTION_DIALOG";
+    dialogConfig: DialogConfig;
+} | {
+    type: "HIDE_ACTION_DIALOG";
+} | {
+    type: "UPDATE_COMPONENT_VALUE";
+    componentId: string;
+    value: unknown;
+} | {
+    type: "UPDATE_FIELD";
+    field: string;
+    value: unknown;
+} | {
+    type: "VALIDATE_FIELD";
+    fieldId: string;
+} | {
+    type: "VALIDATE_SECTION";
+    sectionId: string;
+} | {
+    type: "VALIDATE_STEP";
+    stepId: string;
+};
+interface ComponentAlert {
+    message: string;
+    type: "info" | "warning" | "error" | "success";
+    position: "inline" | "tooltip" | "sidebar";
+    dismissible: boolean;
+    autoHide?: boolean;
+    autoHideDelay?: number;
+}
+interface DialogConfig {
+    type: "email-verification" | "confirmation" | "custom";
+    title?: string;
+    content?: string;
+    templateMetadata?: Record<string, unknown>;
+    buttons?: DialogButton[];
+}
+interface DialogButton {
+    label: string;
+    variant: "default" | "secondary" | "destructive" | "outline" | "ghost";
+    action: string;
+}
+/**
+ * Main Generic Trigger Service
+ */
+export declare class GenericTriggerService {
+    private engine;
+    private services;
+    constructor(formMachine: FormMachine);
+    /**
+     * Initialize triggers from form configuration
+     */
+    initializeFromConfig(config: FormWizardConfig): void;
+    /**
+     * Trigger evaluation for form events
+     */
+    evaluateFormTrigger(triggerType: ExtendedTriggerType, formId: string, formData: Record<string, unknown>, metadata?: Record<string, unknown>): Promise<void>;
+    /**
+     * Trigger evaluation for step events
+     */
+    evaluateStepTrigger(triggerType: ExtendedTriggerType, stepId: string, formData: Record<string, unknown>, metadata?: Record<string, unknown>): Promise<void>;
+    /**
+     * Trigger evaluation for section events
+     */
+    evaluateSectionTrigger(triggerType: ExtendedTriggerType, sectionId: string, formData: Record<string, unknown>, metadata?: Record<string, unknown>): Promise<void>;
+    /**
+     * Trigger evaluation for component events
+     */
+    evaluateComponentTrigger(triggerType: ExtendedTriggerType, componentId: string, currentValue: unknown, previousValue: unknown, formData: Record<string, unknown>, metadata?: Record<string, unknown>): Promise<void>;
+    /**
+     * Register additional triggers dynamically
+     */
+    registerTriggers(targetId: string, triggerContainer: ExtendedTriggerActionContainer): void;
+    /**
+     * Cleanup resources
+     */
+    dispose(): void;
+}
+/**
+ * React Hook for using the Generic Trigger Service
+ */
+export declare function useGenericTriggerService(formMachine: FormMachine): {
+    triggerService: GenericTriggerService;
+    evaluateFormTrigger: (triggerType: ExtendedTriggerType, formId: string, formData: Record<string, unknown>, metadata?: Record<string, unknown>) => Promise<void>;
+    evaluateStepTrigger: (triggerType: ExtendedTriggerType, stepId: string, formData: Record<string, unknown>, metadata?: Record<string, unknown>) => Promise<void>;
+    evaluateSectionTrigger: (triggerType: ExtendedTriggerType, sectionId: string, formData: Record<string, unknown>, metadata?: Record<string, unknown>) => Promise<void>;
+    evaluateComponentTrigger: (triggerType: ExtendedTriggerType, componentId: string, currentValue: unknown, previousValue: unknown, formData: Record<string, unknown>, metadata?: Record<string, unknown>) => Promise<void>;
+};
+export default GenericTriggerService;

package/features/api-integration/services/NavigationExecutor.d.ts

@@ -0,0 +1,2 @@
+export declare const NavigationExecutor: () => null;
+export default NavigationExecutor;

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

@@ -0,0 +1,11 @@
+import { DialogButton, DialogConfig, FormData } from '../../../../../../core/src/index.ts';
+interface ActionDialogProps {
+    config: DialogConfig | null;
+    formData: FormData;
+    onButtonClick: (buttonAction: DialogButton["action"]) => void;
+    onClose: () => void;
+    isOpen: boolean;
+}
+declare const ActionDialog: import('react').NamedExoticComponent<ActionDialogProps>;
+export { ActionDialog };
+export default ActionDialog;

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

@@ -0,0 +1,11 @@
+import { DialogButtonAction, DialogConfig, FormData } from '../../../../../../core/src/index.ts';
+interface ConfirmationDialogProps {
+    config: DialogConfig;
+    formData: FormData;
+    onButtonClick: (buttonAction: DialogButtonAction) => void;
+    onClose: () => void;
+    isOpen: boolean;
+}
+declare const ConfirmationDialog: import('react').NamedExoticComponent<ConfirmationDialogProps>;
+export { ConfirmationDialog };
+export default ConfirmationDialog;

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

@@ -0,0 +1,11 @@
+import { DialogButtonAction, DialogConfig, FormData } from '../../../../../../core/src/index.ts';
+interface EmailVerificationDialogProps {
+    config: DialogConfig;
+    formData: FormData;
+    onButtonClick: (buttonAction: DialogButtonAction) => void;
+    onClose: () => void;
+    isOpen: boolean;
+}
+declare const EmailVerificationDialog: import('react').NamedExoticComponent<EmailVerificationDialogProps>;
+export { EmailVerificationDialog };
+export default EmailVerificationDialog;

package/features/dialog-system/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Dialog System Feature
+ *
+ * Components for various dialog types (confirmation, email verification, etc.)
+ */
+export { default as ActionDialog } from './components/ActionDialog/ActionDialog';
+export { default as ConfirmationDialog } from './components/ConfirmationDialog/ConfirmationDialog';
+export { default as EmailVerificationDialog } from './components/EmailVerificationDialog/EmailVerificationDialog';

package/features/form-runtime/ComponentAdapterComplete/ComponentAdapterComplete.d.ts

@@ -0,0 +1,19 @@
+import { FormErrors, ComponentConfig as FormWizardComponentConfig } from '../../../../../core/src/index.ts';
+import { ComponentValue } from '../../../../../ui/src/index.ts';
+/**
+ * This adapter bridges the gap between the form wizard component config and the flow component config
+ * It converts the simpler form wizard component config to the format expected by the component registry
+ *
+ * Performance optimizations:
+ * - Uses memoized type mappings
+ * - Caches non-form field types array
+ * - Optimized object spread operations
+ */
+export declare const adaptComponentForRegistry: (component: FormWizardComponentConfig, value: ComponentValue, onChange: (value: ComponentValue) => void, readOnly?: boolean, onBlur?: () => void, errors?: FormErrors, state?: {
+    context?: {
+        fieldStates?: Record<string, {
+            error?: string;
+        }>;
+    };
+}) => React.ReactNode;
+export default adaptComponentForRegistry;

package/features/form-runtime/FormWizard/FormWizard.d.ts

@@ -0,0 +1,10 @@
+import { formWizardQueryClient } from '../../../../../ui/src/index.ts';
+import { FormData, FormWizardConfig } from '../../../../../core/src/index.ts';
+export interface FormWizardProps {
+    config: FormWizardConfig;
+    initialData?: FormData;
+    onSubmit?: (data: FormData) => Promise<void> | void;
+    queryClient?: typeof formWizardQueryClient;
+}
+declare const FormWizard: React.FC<FormWizardProps>;
+export default FormWizard;

package/features/form-runtime/components/FormField.d.ts

@@ -0,0 +1,7 @@
+import { ComponentConfig } from '../../../../../core/src/index.ts';
+export interface FormFieldProps {
+    component: ComponentConfig;
+    readOnly?: boolean;
+}
+declare const FormField: React.FC<FormFieldProps>;
+export default FormField;

package/features/form-runtime/components/FormFooter.d.ts

@@ -0,0 +1,5 @@
+interface FormFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+}
+declare const FormFooter: React.FC<FormFooterProps>;
+export default FormFooter;

package/features/form-runtime/components/FormHeader.d.ts

@@ -0,0 +1,9 @@
+import { FormHeaderProps } from '../../../../../ui/src/index.ts';
+/**
+ * User-facing FormHeader that gets data from form context
+ * This component is used in the user-facing form wizard
+ */
+declare const FormHeader: React.FC<Omit<FormHeaderProps, "children"> & {
+    children?: React.ReactNode;
+}>;
+export default FormHeader;

package/features/form-runtime/components/FormSection/FormSection.d.ts

@@ -0,0 +1,6 @@
+import { FormSectionConfig } from '../../../../../../core/src/index.ts';
+export interface FormSectionProps {
+    section: FormSectionConfig;
+}
+declare const FormSection: React.FC<FormSectionProps>;
+export default FormSection;

package/features/form-runtime/components/FormStep/FormStep.d.ts

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

package/features/form-runtime/components/ProgressLoaderRuntime.d.ts

@@ -0,0 +1,12 @@
+import { ProgressLoaderProperties } from '../../../../../core/src/index.ts';
+export interface ProgressLoaderRuntimeProps {
+    /** Component configuration */
+    properties: ProgressLoaderProperties;
+    /** Additional className */
+    className?: string;
+}
+/**
+ * Runtime Progress Loader that auto-starts and signals completion via context
+ */
+export declare const ProgressLoaderRuntime: import('react').NamedExoticComponent<ProgressLoaderRuntimeProps>;
+export default ProgressLoaderRuntime;

package/features/form-runtime/components/StepProgressIndicator/StepProgressIndicator.d.ts

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

package/features/form-runtime/components/displayValue/displayValue.d.ts

@@ -0,0 +1,21 @@
+import { ComponentConfig, ComponentValue } from '../../../../../../core/src/index.ts';
+/**
+ * Default display value renderer for components that don't have custom logic
+ */
+export declare const renderDefaultDisplayValue: (component: ComponentConfig, value: ComponentValue) => React.ReactNode;
+/**
+ * Display value renderer for text-based components (text, email, number)
+ */
+export declare const renderTextDisplayValue: (_component: ComponentConfig, value: ComponentValue) => React.ReactNode;
+/**
+ * Display value renderer for checkbox components
+ */
+export declare const renderCheckboxDisplayValue: (_component: ComponentConfig, value: ComponentValue) => React.ReactNode;
+/**
+ * Display value renderer for radio group components
+ */
+export declare const renderRadioGroupDisplayValue: (component: ComponentConfig, value: ComponentValue) => React.ReactNode;
+/**
+ * Display value renderer for dropdown/select components
+ */
+export declare const renderDropdownDisplayValue: (component: ComponentConfig, value: ComponentValue) => React.ReactNode;

package/features/form-runtime/components/index.d.ts

@@ -0,0 +1,3 @@
+export { default as FormField } from './FormField';
+export { default as FormSection } from './FormSection/FormSection';
+export { default as FormStep } from './FormStep/FormStep';

package/features/form-runtime/components/renderers/DisplayModeRenderer/DisplayModeRenderer.d.ts

@@ -0,0 +1,7 @@
+import { ComponentConfig, ComponentValue } from '../../../../../../../core/src/index.ts';
+interface DisplayModeRendererProps {
+    component: ComponentConfig;
+    fieldValue: ComponentValue;
+}
+export declare const DisplayModeRenderer: React.FC<DisplayModeRendererProps>;
+export {};

package/features/form-runtime/components/renderers/InteractiveFieldRenderer/InteractiveFieldRenderer.d.ts

@@ -0,0 +1,13 @@
+import { ComponentConfig, FormFieldApi } from '../../../../../../../core/src/index.ts';
+import { ComponentValue as RegistryComponentValue } from '../../../../../../../ui/src/index.ts';
+interface InteractiveFieldRendererProps {
+    component: ComponentConfig;
+    field: FormFieldApi;
+    readOnly: boolean;
+    needsFormFieldWrapper: boolean;
+    isSubmitAttempted: boolean;
+    onChange: (value: RegistryComponentValue) => void;
+    onBlur: () => void;
+}
+export declare const InteractiveFieldRenderer: React.FC<InteractiveFieldRendererProps>;
+export {};

package/features/form-runtime/config/configResolver.d.ts

@@ -0,0 +1,14 @@
+import { FormWizardConfig } from '../../../../../core/src/index.ts';
+/**
+ * Resolves a form wizard configuration, expanding any template step references
+ * to their full step configurations
+ */
+export declare function resolveFormWizardConfig(config: FormWizardConfig): Promise<FormWizardConfig>;
+/**
+ * Checks if a configuration contains template step references
+ */
+export declare function hasTemplateSteps(config: FormWizardConfig): boolean;
+/**
+ * Gets template IDs used in a configuration
+ */
+export declare function getUsedTemplateIds(config: FormWizardConfig): string[];

package/features/form-runtime/config/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Form Runtime Configuration
+ *
+ * Configuration resolvers and template utilities
+ */
+export * from './configResolver';
+export * from './templateConfig';
+export * from './templateLoader';
+export { getAvailableGenericTemplatesSync, getTemplateInfo, validateTemplateReferences, } from './templateUtils';

package/features/form-runtime/config/templateConfig.d.ts

@@ -0,0 +1,148 @@
+import { FormStepConfig, TemplateStepConfig } from '../../../../../core/src/index.ts';
+export type TemplateType = "generic" | "team" | null;
+/**
+ * Template permissions configuration
+ */
+export interface TemplatePermissions {
+    /** Can add new components to sections */
+    canAddComponents: boolean;
+    /** Can remove existing components */
+    canRemoveComponents: boolean;
+    /** Can edit component properties */
+    canEditComponentProperties: boolean;
+    /** Can add new sections */
+    canAddSections: boolean;
+    /** Can remove existing sections */
+    canRemoveSections: boolean;
+    /** Can edit section properties */
+    canEditSectionProperties: boolean;
+    /** Can edit step title */
+    canEditStepTitle: boolean;
+    /** Can edit navigation settings */
+    canEditNavigation: boolean;
+    /** Can add/edit actions */
+    canEditActions: boolean;
+    /** Can duplicate the step */
+    canDuplicate: boolean;
+    /** Can delete the step */
+    canDelete: boolean;
+}
+/**
+ * Template display configuration
+ */
+export interface TemplateDisplayConfig {
+    /** Template type for UI display */
+    type: TemplateType;
+    /** Whether template is readonly */
+    isReadonly: boolean;
+    /** Whether to show lock icon */
+    showLockIcon: boolean;
+    /** CSS classes for theme styling */
+    themeClass: string;
+    /** Icon color classes */
+    iconColor: string;
+    /** Tooltip text for locked templates */
+    lockTooltip?: string;
+    /** Badge text for template type */
+    badgeText?: string;
+}
+/**
+ * Complete template configuration
+ */
+export interface TemplateConfig {
+    permissions: TemplatePermissions;
+    display: TemplateDisplayConfig;
+    rules: {
+        /** Message shown when user tries to edit locked content */
+        lockMessage: string;
+        /** Whether this template type supports multiple steps */
+        supportsMultipleSteps: boolean;
+        /** Default navigation behavior */
+        defaultNavigation: {
+            next: {
+                label: string;
+                enabled: boolean;
+            };
+            previous: {
+                label: string;
+                enabled: boolean;
+            };
+        };
+    };
+}
+/**
+ * Gets the complete template configuration for a given template ID or step
+ */
+export declare function getTemplateConfig(templateIdOrStep: string | FormStepConfig | TemplateStepConfig): TemplateConfig;
+/**
+ * Gets template permissions for a given template ID or step
+ */
+export declare function getTemplatePermissions(templateIdOrStep: string | FormStepConfig | TemplateStepConfig): TemplatePermissions;
+/**
+ * Gets template display configuration for a given template ID or step
+ */
+export declare function getTemplateDisplayConfig(templateIdOrStep: string | FormStepConfig | TemplateStepConfig): TemplateDisplayConfig;
+/**
+ * Checks if a specific action is allowed for a template or step
+ */
+export declare function isActionAllowed(templateIdOrStep: string | FormStepConfig | TemplateStepConfig, action: keyof TemplatePermissions): boolean;
+/**
+ * Checks if a step is locked for editing
+ */
+export declare function isStepLocked(step: FormStepConfig | TemplateStepConfig, templateOrigin?: {
+    templateId: string;
+    stepIndex?: number;
+}): boolean;
+/**
+ * Gets the lock message for a template
+ */
+export declare function getLockMessage(templateIdOrStep: string | FormStepConfig | TemplateStepConfig): string;
+/**
+ * Validates if a template action should be blocked and returns appropriate message
+ */
+export declare function validateTemplateAction(templateIdOrStep: string | FormStepConfig | TemplateStepConfig, action: keyof TemplatePermissions): {
+    allowed: boolean;
+    message?: string;
+};
+/**
+ * Gets template type from various input formats
+ */
+export declare function getTemplateTypeFromInput(input: string | FormStepConfig | TemplateStepConfig): TemplateType;
+/**
+ * Utility to check if input represents a generic template
+ */
+export declare function isGenericTemplateInput(input: string | FormStepConfig | TemplateStepConfig): boolean;
+/**
+ * Utility to check if input represents a team template
+ */
+export declare function isTeamTemplateInput(input: string | FormStepConfig | TemplateStepConfig): boolean;
+/**
+ * Creates a comprehensive template info object for UI components
+ */
+export declare function getTemplateInfo(templateIdOrStep: string | FormStepConfig | TemplateStepConfig): {
+    type: TemplateType;
+    permissions: TemplatePermissions;
+    display: TemplateDisplayConfig;
+    rules: {
+        /** Message shown when user tries to edit locked content */
+        lockMessage: string;
+        /** Whether this template type supports multiple steps */
+        supportsMultipleSteps: boolean;
+        /** Default navigation behavior */
+        defaultNavigation: {
+            next: {
+                label: string;
+                enabled: boolean;
+            };
+            previous: {
+                label: string;
+                enabled: boolean;
+            };
+        };
+    };
+    isLocked: boolean;
+    canEdit: boolean;
+    isGeneric: boolean;
+    isTeam: boolean;
+    isRegularStep: boolean;
+};

package/features/form-runtime/config/templateLoader.d.ts

@@ -0,0 +1,25 @@
+import { FormStepConfig, FormTemplate, StepNavigation, TemplateStepConfig } from '../../../../../core/src/index.ts';
+/**
+ * Loads a template by ID, handling both generic and team templates
+ */
+export declare function loadTemplate(templateId: string): Promise<FormTemplate>;
+/**
+ * Resolves a template step reference to a full FormStepConfig
+ */
+export declare function resolveTemplateStep(templateStep: TemplateStepConfig, defaultNavigation?: StepNavigation, stepIndex?: number): Promise<FormStepConfig>;
+/**
+ * Gets template metadata without loading the full template
+ */
+export declare function getTemplateMetadata(templateId: string): Promise<import('../../../../../core/src/index.ts').TemplateMetadata>;
+/**
+ * Lists available templates from both generic and team sources
+ */
+export declare function getAvailableTemplates(): Promise<string[]>;
+/**
+ * Lists available generic templates only (for backward compatibility)
+ */
+export declare function getAvailableGenericTemplates(): string[];
+/**
+ * Clears the template cache (useful for development/testing)
+ */
+export declare function clearTemplateCache(): void;

package/features/form-runtime/config/templateUtils.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Loader-specific template functions for form-wizard-component
+ *
+ * This file only contains functions that depend on the local templateLoader.
+ * All other template utilities should be imported directly from @libs/shared/utils
+ */
+export declare const getAvailableGenericTemplatesSync: () => string[];
+export declare const getTemplateInfo: (templateId: string) => Promise<any>;
+export declare const validateTemplateReferences: (config: import('../../../../../core/src/index.ts').FormWizardConfig) => Promise<{
+    isValid: boolean;
+    errors: string[];
+}>;