import { d as FormEngineConfig, b as FormSchema, e as FieldBehavior, O as OptionItem, a as FormRuntimeApi, f as FormRuntimeConfig, g as FormAppearanceConfig, V as ValidationPreset, h as ValidationRule, i as FormEffect, c as FormRuntimeApiConfig, j as OptionSourceConfig, P as ProcessStatus, S as StatusMeta, T as TaskStatus, A as ApprovalPermission, k as FormDataDeleteParams, C as ChangeRecordQueryParams, l as ChangeRecordListResponse, m as FormDataQueryParams, n as FormInstanceData, I as InitiatorSelectCandidate, o as InitiatorSelectRequirement, p as ProcessBasicInfo, q as ProcessDefinition, r as ProcessTask, s as ReturnableNodeResult, t as ReturnableNode, u as ViewPermissionQueryParams, v as ViewPermissionSummary, w as ApproveParams, x as PreviewParams, y as ProcessRoute, z as ResubmitParams, B as ReturnParams, D as SaveTaskParams, E as TransferParams, W as WithdrawParams, G as TextFieldProps, N as NumberFieldProps, H as TextAreaFieldProps, J as SelectFieldProps, M as MultiSelectFieldProps, K as RadioFieldProps, L as CheckboxFieldProps, Q as DateFieldProps, U as CascadeDateFieldProps, X as AttachmentFieldProps, Y as ImageFieldProps, Z as SubFormFieldProps, _ as UserSelectFieldProps, $ as DepartmentSelectFieldProps, a0 as CascadeSelectFieldProps, a1 as AddressFieldProps, a2 as AssociationFormFieldProps, a3 as EditorFieldProps, a4 as EditorChoiceOption, a5 as SerialNumberFieldProps, a6 as LocationFieldProps, a7 as DigitalSignatureFieldProps, a8 as JSONFieldProps, a9 as AttachmentItem, aa as PreparedFilePreview, ab as FilePreviewCapability, ac as FilePreviewMetadata, ad as FilePreviewRequest, ae as ProcessAction, af as InitiatorSelectedApprovers, ag as ReturnPolicy, ah as ChangeRecord, ai as StandardFormPageMode, aj as LowcodePageSchema } from '../ProcessPreview-DSUIJi5V.mjs';
export { ak as AddressValue, al as ApprovalActionType, am as ApprovalTimeline, an as ApprovalTimelineProps, ao as AssociationFormConfig, ap as AssociationValue, aq as AttachmentImageVariants, ar as BaseFieldProps, as as BaseLayoutNode, at as DataFilter, au as DataLinkageCondition, av as DataLinkageConfig, aw as DateRangeRestriction, ax as DateRestrictionConfig, ay as DateShortcutConfig, az as DateShortcutType, aA as DefaultValueLinkageConfig, aB as DepartmentSearchParams, aC as DepartmentSearchResult, aD as DepartmentSearchScope, aE as DepartmentTreeNode, aF as DigitalSignatureValue, aG as EditorToolbarAction, F as FieldDefinition, aH as FieldLayoutNode, aI as FieldValueSyncConfig, aJ as FilePreviewCapabilityBatch, aK as FilePreviewProvider, aL as FilePreviewRenderMode, aM as FilePreviewSurface, aN as FilePreviewType, aO as FormEffectAction, aP as FormEffectCondition, aQ as FormEffectConditionOperator, aR as FormEngineMode, aS as FormLayoutNode, aT as FormSection, aU as FormSectionProps, aV as FormSubmitBehavior, aW as FormTemplateConfig, aX as GridLayoutCell, aY as GridLayoutNode, aZ as ImageCompressionConfig, a_ as ImageCompressionVariantConfig, a$ as ImageVariant, b0 as InitiatorSelectScope, b1 as JSONFieldEditorContext, b2 as JSONFieldRendererContext, b3 as LayoutVisibleWhen, b4 as LinkedFormOptionConfig, b5 as LocationValue, b6 as LowcodePageMeta, b7 as LowcodePageNode, b8 as LowcodePageNodeType, b9 as OptionSourceType, ba as PeopleShortcutConfig, bb as PeopleShortcutType, bc as PreviewImageItem, bd as ProcessNodeType, be as ProcessPreview, bf as ProcessPreviewProps, bg as RuntimeAuthHeadersProvider, bh as RuntimeDataQueryParams, bi as RuntimeDataQueryResult, bj as RuntimeRequestConfig, R as RuntimeResponse, bk as RuntimeUploadOptions, bl as RuntimeUploadProvider, bm as SectionLayoutNode, bn as SignaturePoint, bo as StepLayoutItem, bp as StepsLayoutNode, bq as SubFormColumn, br as TabLayoutItem, bs as TabsLayoutNode, bt as TextShortcutConfig, bu as TextShortcutType, bv as UserDisplayFormat, bw as UserItem } from '../ProcessPreview-DSUIJi5V.mjs';
import * as React from 'react';
import React__default from 'react';
import { D as DataManagementConfigScope, a as DataManagementConfig, F as FormActionPermission } from '../dataManagementApi-p_HOhQnA.mjs';
export { b as DataManagementDensity, c as DataManagementField, d as DataManagementFilterGroup, f as DataManagementFilterRule, g as DataManagementListResult, h as DataManagementQuery, i as DataManagementSort, j as advancedSearchDataManagement, k as batchApproveDataManagementRows, l as buildFilterPayload, m as deleteDataManagementRows, n as downloadDataManagementImportTemplate, o as exportDataManagementRows, p as getDataManagementConfig, q as getDataManagementSchema, r as getDataManagementTransferRecords, s as getSystemFieldsForFormType, t as importDataManagementRows, u as importPreviewDataManagementRows, v as normalizeColumnConfig, w as normalizeDataManagementFields, x as normalizeDataManagementList, y as saveDataManagementConfig } from '../dataManagementApi-p_HOhQnA.mjs';

interface FormContextValue {
    mode: FormEngineConfig['mode'];
    schema: FormSchema;
    formData: Record<string, any>;
    fieldErrors: Record<string, string>;
    fieldBehaviors: Record<string, FieldBehavior>;
    fieldOverrides: Record<string, Record<string, any>>;
    layoutBehaviors: Record<string, FieldBehavior>;
    dynamicOptions: Record<string, OptionItem[]>;
    api: FormRuntimeApi;
    runtime: FormRuntimeConfig;
    config: Pick<FormEngineConfig, 'mode' | 'formUuid' | 'appType' | 'formInstanceId' | 'submit' | 'defaultUploadProvider'>;
    setFieldValue: (fieldId: string, value: any) => void;
    setFieldError: (fieldId: string, error?: string | null) => void;
    getFieldValue: (fieldId: string) => any;
    getFormData: () => Record<string, any>;
    validateField: (fieldId: string) => Promise<boolean>;
    validateAll: () => Promise<boolean>;
    validateAllWithErrors: () => Promise<Record<string, string>>;
    resetForm: () => void;
    registerField: (fieldId: string) => void;
    unregisterField: (fieldId: string) => void;
}
declare const FormContext: React.Context<FormContextValue | null>;
declare function useFormContext(): FormContextValue;

interface FormProviderProps {
    schema: FormSchema;
    config: FormEngineConfig;
    initialValues?: Record<string, any>;
    components?: Record<string, React__default.ComponentType<any>>;
    runtime?: FormRuntimeConfig;
    children: React__default.ReactNode;
}
declare function FormProvider({ schema, config, initialValues, components, runtime, children, }: FormProviderProps): React__default.FunctionComponentElement<React__default.ProviderProps<FormContextValue | null>>;

interface ComponentRegistryContextValue {
    registry: Record<string, React__default.ComponentType<any>>;
    register: (name: string, component: React__default.ComponentType<any>) => void;
}
declare const ComponentRegistryContext: React__default.Context<ComponentRegistryContextValue | null>;
declare function ComponentRegistryProvider({ components, children, }: {
    components: Record<string, React__default.ComponentType<any>>;
    children: React__default.ReactNode;
}): React__default.ReactElement;
declare function useComponent(componentName: string): React__default.ComponentType<any> | null;

interface FormRendererProps {
    className?: string;
    fieldClassName?: string;
    columns?: 1 | 2 | 3 | 4;
    size?: 'compact' | 'default' | 'large';
}
declare function FormRenderer({ className, fieldClassName, columns, size, }: FormRendererProps): React__default.JSX.Element;

interface FormShellProps {
    children: React__default.ReactNode;
    appearance?: FormAppearanceConfig;
    className?: string;
}
declare function FormShell({ children, appearance, className }: FormShellProps): React__default.JSX.Element;

interface FormActionsProps {
    className?: string;
    submitText?: string;
    resetText?: string;
    showReset?: boolean;
    onSubmit?: (values: Record<string, any>) => Promise<void>;
    submitSuccessMode?: 'stay' | 'callback';
}
declare function FormActions({ className, submitText, resetText, showReset, onSubmit, }: FormActionsProps): React__default.JSX.Element | null;

declare const defaultComponentRegistry: Record<string, React__default.ComponentType<any>>;

/**
 * 预设校验规则常量
 */
declare const VALIDATION_PRESETS: Record<ValidationPreset, {
    pattern: RegExp;
    message: string;
}>;
/**
 * Validate a single field value against its rules.
 * Returns the first error message encountered, or null if valid.
 */
declare function validateField(value: any, rules: ValidationRule[]): Promise<string | null>;
/**
 * Validate all fields in a form.
 * Returns a map of fieldId → error message for fields that have errors.
 */
declare function validateAllFields(formData: Record<string, any>, fieldRules: Record<string, ValidationRule[]>): Promise<Record<string, string>>;

/**
 * Evaluate form effects based on current form data.
 * Returns a map of fieldId → FieldBehavior adjustments.
 * Only behavior-changing actions (show/hide/enable/disable) are processed.
 * setValue actions are ignored in behavior evaluation.
 */
declare function evaluateEffects(effects: FormEffect[], formData: Record<string, any>, currentBehaviors: Record<string, FieldBehavior>): Record<string, FieldBehavior>;

interface FieldWrapperProps {
    fieldId: string;
    label: string;
    required?: boolean;
    tips?: string;
    className?: string;
    labelClassName?: string;
    tipsClassName?: string;
    children: React__default.ReactNode;
}
declare function FieldWrapper({ fieldId, label, required, tips, className, labelClassName, tipsClassName, children, }: FieldWrapperProps): React__default.JSX.Element;

interface FormContainerProps {
    title?: string;
    description?: string;
    children: React__default.ReactNode;
    maxWidth?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
    className?: string;
}
declare function FormContainer({ title, description, children, maxWidth, className, }: FormContainerProps): React__default.JSX.Element;

declare function createFormRuntimeApi(config?: FormRuntimeApiConfig): FormRuntimeApi;

/**
 * 解析选项数据源，返回选项列表
 */
declare function resolveOptions(config: OptionSourceConfig, runtime: FormRuntimeConfig | undefined, formData: Record<string, any>, searchKeyword?: string): Promise<OptionItem[]>;
/**
 * 解析默认值联动（用于非选择类字段的数据联动默认值）
 */
declare function resolveDefaultValueLinkage(config: {
    formUuid: string;
    targetFieldId: string;
    conditions: any[];
    conditionLogic?: string;
}, runtime: FormRuntimeConfig | undefined, formData: Record<string, any>): Promise<any>;

/** 流程状态元映射 */
declare const PROCESS_STATUS_META: Record<ProcessStatus, StatusMeta>;
/** 任务状态元映射 */
declare const TASK_STATUS_META: Record<TaskStatus, StatusMeta>;

/** 获取流程基本信息 */
declare function getProcessBasic(request: FormRuntimeApi['request'], formInstId: string): Promise<ProcessBasicInfo>;
/** 获取流程进度（任务列表） */
declare function getProcessProgress(request: FormRuntimeApi['request'], formInstId: string): Promise<ProcessTask[]>;
/** 检查当前用户审批权限 */
declare function checkUserApproval(request: FormRuntimeApi['request'], formInstId: string): Promise<ApprovalPermission>;
/** 审批（同意/拒绝） */
declare function handleApproval(request: FormRuntimeApi['request'], params: ApproveParams): Promise<any>;
/** 撤销流程 */
declare function withdrawProcess(request: FormRuntimeApi['request'], params: WithdrawParams): Promise<any>;
/** 转交任务 */
declare function transferTask(request: FormRuntimeApi['request'], params: TransferParams): Promise<any>;
/** 退回任务 */
declare function returnTask(request: FormRuntimeApi['request'], params: ReturnParams): Promise<any>;
/** 重新提交任务 */
declare function resubmitTask(request: FormRuntimeApi['request'], params: ResubmitParams): Promise<any>;
/** 暂存任务 */
declare function saveTask(request: FormRuntimeApi['request'], params: SaveTaskParams): Promise<any>;
/** 获取可退回节点 */
declare function getReturnableNodes(request: FormRuntimeApi['request'], taskId: string): Promise<ReturnableNode[]>;
/** 获取可退回节点和退回策略 */
declare function getReturnableNodeResult(request: FormRuntimeApi['request'], taskId: string): Promise<ReturnableNodeResult>;
/** 预览流程路由 */
declare function previewProcess(request: FormRuntimeApi['request'], params: PreviewParams): Promise<ProcessRoute[]>;
declare function getInitiatorSelectRequirements(request: FormRuntimeApi['request'], params: {
    formUuid: string;
    appType: string;
    data: Record<string, any>;
    submissionDepartmentId?: string;
}): Promise<InitiatorSelectRequirement[]>;
declare function getResubmitInitiatorSelectRequirements(request: FormRuntimeApi['request'], params: {
    taskId: string;
    formUuid: string;
    appType: string;
    data: Record<string, any>;
}): Promise<InitiatorSelectRequirement[]>;
declare function getInitiatorSelectCandidates(request: FormRuntimeApi['request'], params: {
    formUuid: string;
    appType: string;
    nodeId: string;
    page?: number;
    pageSize?: number;
    keyword?: string;
    departmentId?: string;
}): Promise<{
    items: InitiatorSelectCandidate[];
    total: number;
    page: number;
    pageSize: number;
}>;
/** 获取流程定义 */
declare function getProcessDefinition(request: FormRuntimeApi['request'], formUuid: string): Promise<ProcessDefinition>;
/** 触发回调等待任务 */
declare function triggerCallbackTask(request: FormRuntimeApi['request'], params: {
    taskId: string;
    payload?: Record<string, any>;
}): Promise<any>;
/** 获取表单实例数据 */
declare function getFormData(request: FormRuntimeApi['request'], params: FormDataQueryParams): Promise<FormInstanceData>;
/** 删除表单数据 */
declare function deleteFormData(request: FormRuntimeApi['request'], params: FormDataDeleteParams): Promise<any>;
/** 获取表单变更记录 */
declare function getChangeRecords(request: FormRuntimeApi['request'], params: ChangeRecordQueryParams): Promise<ChangeRecordListResponse>;
/** 获取视图权限摘要 */
declare function getViewPermission(request: FormRuntimeApi['request'], params: ViewPermissionQueryParams): Promise<ViewPermissionSummary>;

declare function TextField(props: TextFieldProps): React__default.JSX.Element | null;

declare function NumberField(props: NumberFieldProps): React__default.JSX.Element | null;

declare function TextAreaField(props: TextAreaFieldProps): React__default.JSX.Element | null;

declare function SelectField(props: SelectFieldProps): React__default.JSX.Element | null;

declare function MultiSelectField(props: MultiSelectFieldProps): React__default.JSX.Element | null;

declare function RadioField(props: RadioFieldProps): React__default.JSX.Element | null;

declare function CheckboxField(props: CheckboxFieldProps): React__default.JSX.Element | null;

declare function DateField(props: DateFieldProps): React__default.JSX.Element | null;

declare function CascadeDateField(props: CascadeDateFieldProps): React__default.JSX.Element | null;

declare function AttachmentField(props: AttachmentFieldProps): React__default.JSX.Element | null;

declare function ImageField(props: ImageFieldProps): React__default.JSX.Element | null;

declare function SubFormField(props: SubFormFieldProps): React__default.JSX.Element | null;

declare function UserSelectField(props: UserSelectFieldProps): React__default.JSX.Element | null;

declare function DepartmentSelectField(props: DepartmentSelectFieldProps): React__default.JSX.Element | null;

declare function CascadeSelectField(props: CascadeSelectFieldProps): React__default.JSX.Element | null;

declare function AddressField(props: AddressFieldProps): React__default.JSX.Element | null;

declare function AssociationFormField(props: AssociationFormFieldProps): React__default.JSX.Element | null;

interface RichTextEditorCoreProps {
    value?: string;
    onChange?: (value: string) => void;
    disabled?: boolean;
    placeholder?: string;
    rows?: number;
    maxLength?: number;
    height?: number | string;
    toolbarConfig?: EditorFieldProps['toolbarConfig'];
    uploadBucketName?: string;
    maxImageSize?: number;
    allowedImageTypes?: string[];
    fontFamilies?: EditorChoiceOption[];
    fontSizes?: EditorChoiceOption[];
    colorPresets?: string[];
    api?: Partial<FormRuntimeApi>;
    inputClassName?: string;
    fieldId?: string;
    mobile?: boolean;
}
declare function RichTextEditorCore({ value, onChange, disabled, inputClassName, placeholder, rows, maxLength, height, toolbarConfig, uploadBucketName, maxImageSize, allowedImageTypes, fontFamilies, fontSizes, colorPresets, api, fieldId, mobile, }: RichTextEditorCoreProps): React__default.JSX.Element;
declare function EditorField(props: EditorFieldProps): React__default.JSX.Element | null;

declare function SerialNumberField(props: SerialNumberFieldProps): React__default.JSX.Element | null;

declare function LocationField(props: LocationFieldProps): React__default.JSX.Element | null;

declare function DigitalSignatureField(props: DigitalSignatureFieldProps): React__default.JSX.Element | null;

declare function JSONField(props: JSONFieldProps): React__default.JSX.Element | null;

interface FormGridProps {
    columns?: 1 | 2 | 3 | 4;
    gap?: number | string;
    columnGap?: number | string;
    rowGap?: number | string;
    columnRatios?: number[];
    className?: string;
    children: React__default.ReactNode;
}
declare function FormGrid({ columns, gap, columnGap, rowGap, columnRatios, className, children, }: FormGridProps): React__default.JSX.Element;

interface FormTabItem {
    key: string;
    label: string;
    children: React__default.ReactNode;
}
interface FormTabsProps {
    items: FormTabItem[];
    defaultActiveKey?: string;
    className?: string;
    tabClassName?: string;
}
declare function FormTabs({ items, defaultActiveKey, className, tabClassName }: FormTabsProps): React__default.JSX.Element;

interface FormStepItem {
    key: string;
    title: string;
    description?: string;
    children: React__default.ReactNode;
}
interface FormStepsProps {
    items: FormStepItem[];
    className?: string;
    onStepChange?: (step: number) => void;
}
declare function FormSteps({ items, className, onStepChange }: FormStepsProps): React__default.JSX.Element;

interface FormSummaryProps {
    className?: string;
    labelClassName?: string;
    valueClassName?: string;
    columns?: 1 | 2 | 3;
    fields?: string[];
}
declare function FormSummary({ className, labelClassName, valueClassName, columns, fields, }: FormSummaryProps): React__default.JSX.Element;

declare const unwrapFilePreviewPayload: (payload: any) => any;
declare const normalizePreviewBlobResponse: (response: unknown) => Blob;
declare const normalizePreviewBlobContent: (response: unknown) => Promise<Blob>;
declare const isDirectStorageItem: (item: AttachmentItem) => boolean;
declare const getPreviewItemKey: (item: AttachmentItem, index?: number) => string;
declare const getPreviewSourceUrl: (item: AttachmentItem) => string;
declare const resolveLocalPreviewCapability: (item: AttachmentItem) => FilePreviewCapability;
declare const prepareFilePreview: (options: {
    item: AttachmentItem;
    api: FormRuntimeApi;
    appType?: string;
    bucketName: string;
}) => Promise<PreparedFilePreview>;
declare const loadPreviewBlob: (request: FormRuntimeApi["request"], url: string) => Promise<Blob>;
declare const convertHeicPreview: (request: FormRuntimeApi["request"], url: string) => Promise<string>;

declare const formatPreviewFileSize: (size?: number) => string;
declare const resolvePreviewServiceUrl: (url?: string, servicePrefix?: string) => string;
interface FilePreviewContentProps {
    metadata: FilePreviewMetadata;
    request: FilePreviewRequest;
    servicePrefix?: string;
    onDownload?: () => void;
}
declare const FilePreviewContent: ({ metadata, request, servicePrefix, onDownload, }: FilePreviewContentProps) => React__default.JSX.Element;

interface FilePreviewPageProps {
    ticket: string;
    request: FilePreviewRequest;
    servicePrefix?: string;
}
declare const FilePreviewPage: ({ ticket, request, servicePrefix, }: FilePreviewPageProps) => React__default.JSX.Element;

interface UseFilePreviewOptions {
    items: AttachmentItem[];
    api: FormRuntimeApi;
    appType?: string;
    bucketName: string;
    enabled?: boolean;
    requireServerCapability?: boolean;
}
declare const useFilePreviewController: ({ items, api, appType, bucketName, enabled, requireServerCapability, }: UseFilePreviewOptions) => {
    canPreview: (item: AttachmentItem) => boolean;
    getCapability: (item: AttachmentItem) => FilePreviewCapability;
    openPreview: (item: AttachmentItem) => Promise<void>;
    openingKey: string;
    isOpening: (item: AttachmentItem) => boolean;
    downloadItem: (item: AttachmentItem, prepared?: PreparedFilePreview | null) => Promise<void>;
    previewHost: React__default.JSX.Element | null;
};
declare const FilePreviewCapabilityError: ({ message }: {
    message: string;
}) => React__default.JSX.Element;

interface UseFormEngineReturn {
    formData: Record<string, any>;
    setFieldValue: (fieldId: string, value: any) => void;
    getFieldValue: (fieldId: string) => any;
    getFormData: () => Record<string, any>;
    validateAll: () => Promise<boolean>;
    resetForm: () => void;
    mode: string;
    fieldBehaviors: Record<string, FieldBehavior>;
    fieldErrors: Record<string, string>;
}
declare function useFormEngine(schema: FormSchema, config: FormEngineConfig): UseFormEngineReturn;

interface UseFormDataReturn {
    formData: Record<string, any>;
    setFieldValue: (fieldId: string, value: any) => void;
    getFieldValue: (fieldId: string) => any;
    getFormData: () => Record<string, any>;
    resetForm: () => void;
    dirtyFields: Set<string>;
}
declare function useFormData(initialValues?: Record<string, any>): UseFormDataReturn;

interface UseFieldBehaviorOptions {
    fieldId: string;
    permissions?: Record<string, FieldBehavior>;
    effects?: FormEffect[];
    formData: Record<string, any>;
    defaultBehavior?: FieldBehavior;
}
/**
 * Computes the final behavior for a field.
 * Priority: permissions > effects > defaultBehavior > 'NORMAL'
 */
declare function useFieldBehavior({ fieldId, permissions, effects, formData, defaultBehavior, }: UseFieldBehaviorOptions): FieldBehavior;

interface SubmitConfig {
    beforeSubmit?: (values: Record<string, any>) => Promise<boolean | void>;
    afterSubmit?: (response: any) => Promise<void>;
    submitSuccessMode?: 'redirect' | 'stay' | 'callback';
    redirectUrl?: string;
}
interface UseFormSubmitReturn {
    submit: (formData: Record<string, any>, validateFn: () => Promise<boolean>) => Promise<void>;
    isSubmitting: boolean;
    submitError: string | null;
}
declare function useFormSubmit(config?: SubmitConfig): UseFormSubmitReturn;

interface DeviceDetectResult {
    isMobile: boolean;
}
declare function useDeviceDetect(): DeviceDetectResult;

interface UseFieldPermissionOptions {
    viewPermissions?: ViewPermissionSummary;
    processDefinition?: ProcessDefinition;
    currentTask?: ProcessTask;
    isApprover?: boolean;
    mode: 'readonly' | 'edit';
}
interface UseFieldPermissionReturn {
    fieldBehaviors: Record<string, FieldBehavior>;
    computeBehaviors: () => Record<string, FieldBehavior>;
}
/**
 * 字段权限计算 hook
 * 根据不同场景（普通详情、流程审批等）计算字段行为映射
 */
declare function useFieldPermission(options: UseFieldPermissionOptions): UseFieldPermissionReturn;

interface UseFormDetailOptions {
    formUuid: string;
    appType: string;
    formInstanceId: string;
    fieldIds?: readonly string[];
    onPermissionDenied?: () => void;
}
interface UseFormDetailReturn {
    loading: boolean;
    mode: 'readonly' | 'edit';
    formData: Record<string, any> | null;
    instanceInfo: FormInstanceData | null;
    permissions: ViewPermissionSummary | null;
    fieldBehaviors: Record<string, FieldBehavior>;
    switchToEdit: () => void;
    switchToReadonly: () => void;
    saveChanges: (values: Record<string, any>) => Promise<boolean>;
    deleteInstance: () => Promise<boolean>;
    canEdit: boolean;
    canDelete: boolean;
    canViewChangeRecords: boolean;
}
/**
 * 详情页核心逻辑 hook
 * 处理数据加载、权限计算、模式切换、保存和删除
 */
declare function useFormDetail(options: UseFormDetailOptions): UseFormDetailReturn;

interface UseProcessDetailOptions {
    formUuid: string;
    appType: string;
    formInstanceId: string;
    fieldIds?: readonly string[];
}
interface UseProcessDetailReturn {
    loading: boolean;
    processInfo: ProcessBasicInfo | null;
    processStatus: ProcessStatus | null;
    currentTask: ProcessTask | null;
    progressList: ProcessTask[];
    formData: Record<string, any> | null;
    instanceInfo: FormInstanceData | null;
    accessDenied: boolean;
    loadError: string | null;
    isApprover: boolean;
    activeActions: ProcessAction[];
    fieldBehaviors: Record<string, FieldBehavior>;
    mode: 'readonly' | 'edit';
    isOriginatorReturn: boolean;
    isProcessCompleted: boolean;
    canWithdraw: boolean;
    canEdit: boolean;
    canDelete: boolean;
    canViewWorkflow: boolean;
    canViewChangeRecords: boolean;
    dataVersion: number;
    switchToEdit: () => void;
    switchToReadonly: () => void;
    saveChanges: (values: Record<string, any>) => Promise<boolean>;
    deleteInstance: () => Promise<boolean>;
    refreshDetail: () => Promise<void>;
    refreshProgress: () => Promise<void>;
}
/**
 * 流程详情核心逻辑 hook
 */
declare function useProcessDetail(options: UseProcessDetailOptions): UseProcessDetailReturn;

interface UseApprovalActionsOptions {
    formInstanceId: string;
    formUuid: string;
    appType: string;
    currentTaskId?: string;
    onActionComplete?: (action: string) => Promise<void> | void;
    getFormValues?: () => Record<string, any>;
}
interface UseApprovalActionsReturn {
    approve: (comments?: string) => Promise<boolean>;
    reject: (comments?: string) => Promise<boolean>;
    transfer: (userId: string, reason?: string) => Promise<boolean>;
    returnTo: (nodeId: string, reason?: string) => Promise<boolean>;
    withdraw: (reason?: string) => Promise<boolean>;
    save: () => Promise<boolean>;
    resubmit: (comments?: string, selectedApprovers?: InitiatorSelectedApprovers) => Promise<boolean>;
    callbackTask: (payload?: Record<string, any>) => Promise<boolean>;
    isLoading: boolean;
    currentAction: string | null;
    returnableNodes: ReturnableNode[];
    returnPolicy: ReturnPolicy | null;
    loadReturnableNodes: () => Promise<ReturnableNode[]>;
}
/**
 * 审批操作逻辑 hook
 */
declare function useApprovalActions(options: UseApprovalActionsOptions): UseApprovalActionsReturn;

interface UseChangeRecordsOptions {
    formUuid: string;
    appType: string;
    formInstanceId: string;
    pageSize?: number;
    autoLoad?: boolean;
}
interface UseChangeRecordsReturn {
    records: ChangeRecord[];
    loading: boolean;
    total: number;
    page: number;
    loadMore: () => Promise<void>;
    refresh: () => Promise<void>;
    hasMore: boolean;
}
/**
 * 变更记录加载 hook
 */
declare function useChangeRecords(options: UseChangeRecordsOptions): UseChangeRecordsReturn;

interface UseFormNavigationOptions {
    appType: string;
    formUuid: string;
    formType?: 'form' | 'process';
    mode?: 'redirect' | 'stay' | 'callback';
    redirectDelay?: number;
    basePath?: string;
    onStay?: (formInstId: string) => void;
}
interface UseFormNavigationReturn {
    navigateToDetail: (formInstId: string) => void;
    navigateToProcessDetail: (formInstId: string) => void;
    handlePostSubmit: (formInstId: string) => void;
    isRedirecting: boolean;
    countdown: number;
    cancelRedirect: () => void;
}
declare function useFormNavigation(options: UseFormNavigationOptions): UseFormNavigationReturn;

interface UseDraftStorageOptions {
    appType: string;
    formUuid: string;
    autoRestore?: boolean;
}
interface UseDraftStorageReturn {
    hasDraft: boolean;
    draftData: Record<string, any> | null;
    draftTimestamp: number | null;
    saveDraft: (data: Record<string, any>) => void;
    restoreDraft: () => Record<string, any> | null;
    clearDraft: () => void;
}
/**
 * 草稿暂存 hook
 * 使用 localStorage 存储表单草稿数据
 */
declare function useDraftStorage(options: UseDraftStorageOptions): UseDraftStorageReturn;

/**
 * 类型安全的表单 Schema 定义辅助函数
 * 提供 TypeScript 类型推导和编辑器智能提示
 */
declare function defineFormSchema(schema: FormSchema): FormSchema;

declare const extractFormValues: (formInstance: unknown, fieldIds?: readonly string[]) => Record<string, any> | null;

declare function decodeHtmlEntities(value: string): string;
declare function sanitizeRichTextHtml(value?: string): string;
declare function normalizeRichTextHtml(value?: unknown): string;

declare function normalizeOperation(operation?: string): string;
declare function hasViewOperation(operations: string[] | undefined, expected: string): boolean;
declare function normalizeFieldBehaviors(permissions: ViewPermissionSummary | null | undefined, mode: 'readonly' | 'edit'): Record<string, FieldBehavior>;
declare function hasViewPermission(permissions: ViewPermissionSummary | null | undefined): boolean;

interface FormSummaryCardProps {
    title?: string;
    formInstanceId?: string;
    creator?: {
        name: string;
        avatar?: string;
        department?: string;
    };
    createdAt?: string;
    status?: {
        label: string;
        tone: 'brand' | 'success' | 'danger' | 'neutral' | 'warning';
    };
    className?: string;
    children?: React__default.ReactNode;
}
declare const FormSummaryCard: React__default.FC<FormSummaryCardProps>;

interface ChangeRecordsProps {
    records?: ChangeRecord[];
    loading?: boolean;
    defaultExpanded?: boolean;
    hasMore?: boolean;
    onLoadMore?: () => void;
    onExpand?: () => void;
    className?: string;
    renderItem?: (record: ChangeRecord) => React__default.ReactNode;
}
declare const ChangeRecords: React__default.FC<ChangeRecordsProps>;

interface RecordChangePanelProps {
    records?: ChangeRecord[];
    loading?: boolean;
    total?: number;
    page?: number;
    pageSize?: number;
    defaultExpanded?: boolean;
    hasMore?: boolean;
    onLoadMore?: () => void;
    onRefresh?: () => void;
    onExpand?: () => void;
    onPageChange?: (page: number, pageSize: number) => void;
    className?: string;
}
declare const RecordChangePanel: React__default.FC<RecordChangePanelProps>;

interface ApprovalActionBarProps {
    actions: ProcessAction[];
    onApprove?: (comments?: string) => Promise<void> | void;
    onReject?: (comments?: string) => Promise<void> | void;
    onTransfer?: (userId: string, reason?: string) => Promise<void> | void;
    onReturn?: (nodeId: string, reason?: string) => Promise<void> | void;
    onWithdraw?: (reason?: string) => Promise<void> | void;
    onSave?: () => Promise<void> | void;
    onResubmit?: (comments?: string) => Promise<void> | void;
    onCallback?: () => Promise<void> | void;
    returnableNodes?: ReturnableNode[];
    returnPolicy?: ReturnPolicy | null;
    onLoadReturnableNodes?: () => Promise<ReturnableNode[] | void> | void;
    renderTransferSelector?: (props: {
        value?: string;
        onChange: (userId: string) => void;
    }) => React__default.ReactNode;
    renderReturnNodeLabel?: (node: ReturnableNode) => React__default.ReactNode;
    renderActionModalExtra?: (action: ProcessAction) => React__default.ReactNode;
    maxMobileButtons?: number;
    className?: string;
    inDrawer?: boolean;
    maxWidth?: number | string;
}
declare const ApprovalActionBar: React__default.FC<ApprovalActionBarProps>;

interface ApprovalActionsProps {
    actions: ProcessAction[];
    onApprove?: (comments?: string) => Promise<void> | void;
    onReject?: (comments?: string) => Promise<void> | void;
    onTransfer?: () => void;
    onReturn?: () => void;
    onWithdraw?: (reason?: string) => Promise<void> | void;
    onSave?: () => Promise<void> | void;
    layout?: 'horizontal' | 'vertical';
    maxVisible?: number;
    className?: string;
}
declare const ApprovalActions: React__default.FC<ApprovalActionsProps>;

interface ActionConfig {
    key: string;
    label: string;
    type?: 'primary' | 'default' | 'danger' | 'text';
    onClick: () => void | Promise<void>;
    loading?: boolean;
    disabled?: boolean;
    disabledReason?: string;
    visible?: boolean;
    confirm?: {
        title: string;
        content: string;
        okText?: string;
        cancelText?: string;
    };
    icon?: React__default.ReactNode;
    priority?: number;
    placement?: 'left' | 'right';
}
interface FormActionBarProps {
    actions: ActionConfig[];
    position?: 'bottom-fixed' | 'inline';
    className?: string;
}
declare const FormActionBar: React__default.FC<FormActionBarProps>;

interface StickyActionBarProps {
    actions: ActionConfig[];
    className?: string;
    maxMobileButtons?: number;
    layoutMode?: 'default' | 'approval';
    align?: 'left' | 'center' | 'right';
    inDrawer?: boolean;
    maxWidth?: number | string;
    position?: 'sticky' | 'fixed' | 'inline';
    surface?: 'default' | 'transparent';
}
declare const StickyActionBar: React__default.FC<StickyActionBarProps>;

interface RuntimePageShellProps {
    children: React__default.ReactNode;
    actions?: React__default.ReactNode;
    loading?: boolean;
    loadingTip?: string;
    accessDenied?: boolean;
    error?: React__default.ReactNode;
    empty?: React__default.ReactNode;
    className?: string;
    contentClassName?: string;
    maxWidth?: number | string;
    inDrawer?: boolean;
}
declare const RuntimePageShell: React__default.FC<RuntimePageShellProps>;

interface SummaryPanelMetaItem {
    key: string;
    label: string;
    value?: React__default.ReactNode;
    icon?: React__default.ReactNode;
}
interface SummaryPanelProps {
    title?: React__default.ReactNode;
    eyebrow?: React__default.ReactNode;
    showEyebrow?: boolean;
    status?: StatusMeta;
    creator?: {
        name?: string;
        avatar?: string;
        department?: string;
    };
    createdAt?: React__default.ReactNode;
    metaItems?: SummaryPanelMetaItem[];
    className?: string;
    children?: React__default.ReactNode;
}
declare const SummaryPanel: React__default.FC<SummaryPanelProps>;

interface DraftManagerProps {
    hasDraft: boolean;
    draftTimestamp?: number | null;
    onRestore: () => void;
    onDiscard: () => void;
    className?: string;
}
declare const DraftManager: React__default.FC<DraftManagerProps>;

type DetailRenderer = (props: {
    record: any;
    formInstanceId?: string;
    onClose: () => void;
}) => React__default.ReactNode;
type DetailPageUrlBuilder = (props: {
    record: any;
    formInstanceId: string;
}) => string | undefined;
type SubmitRenderer = (props: {
    onClose: () => void;
    onSubmitted: () => void;
}) => React__default.ReactNode;
interface DataManagementRowAction {
    key: string;
    label: string;
    danger?: boolean;
    requiredAction?: FormActionPermission;
    onClick: (record: any) => void;
}
type DataManagementPermissionMode = 'auto' | 'manual' | 'off';
type DataManagementActionOverrides = Partial<Record<FormActionPermission, boolean>>;
interface DataManagementListProps {
    appType: string;
    formUuid: string;
    detailBasePath?: string;
    menuFormUuid?: string;
    readonly?: boolean;
    fullHeight?: boolean;
    configScope?: DataManagementConfigScope;
    title?: string;
    formTitle?: string;
    formType?: string;
    schema?: FormSchema;
    components?: Record<string, React__default.ComponentType<any>>;
    forcedConfig?: DataManagementConfig;
    showForcedConfig?: boolean;
    detailRenderer?: DetailRenderer;
    detailPageUrlBuilder?: DetailPageUrlBuilder;
    submitRenderer?: SubmitRenderer;
    requestOverride?: FormRuntimeApi['request'] | FormRuntimeApiConfig;
    allowSchemaFallback?: boolean;
    rowActions?: DataManagementRowAction[];
    maxVisibleRowActions?: number;
    permissionMode?: DataManagementPermissionMode;
    actionOverrides?: DataManagementActionOverrides;
}
declare const DataManagementList: React__default.FC<DataManagementListProps>;

interface SubmitSuccessInfo {
    formInstanceId: string;
    message?: string;
}
interface FormSubmitTemplateProps {
    schema: FormSchema;
    config: FormEngineConfig;
    formType?: 'form' | 'process';
    submitSuccessMode?: 'redirect' | 'stay' | 'continue';
    enableDraft?: boolean;
    enableProcessPreview?: boolean;
    enableSubmissionDepartmentSelect?: boolean;
    departmentOptions?: OptionItem[];
    header?: React__default.ReactNode;
    footer?: React__default.ReactNode;
    beforeForm?: React__default.ReactNode;
    afterForm?: React__default.ReactNode;
    renderDepartmentSelector?: (props: {
        value?: string;
        onChange: (value?: string) => void;
        options: OptionItem[];
    }) => React__default.ReactNode;
    renderForm?: (props: {
        schema: FormSchema;
        config: FormEngineConfig;
    }) => React__default.ReactNode;
    renderSuccess?: (info: SubmitSuccessInfo) => React__default.ReactNode;
    onSubmitSuccess?: (formInstId: string) => void;
    initialValues?: Record<string, any>;
    components?: Record<string, React__default.ComponentType<any>>;
    inDrawer?: boolean;
}
declare const FormSubmitTemplate: React__default.FC<FormSubmitTemplateProps>;

interface FormDetailTemplateProps {
    schema: FormSchema;
    formUuid: string;
    appType: string;
    formInstanceId: string;
    enableEdit?: boolean;
    enableDelete?: boolean;
    enableChangeRecords?: boolean;
    header?: React__default.ReactNode;
    footer?: React__default.ReactNode;
    renderSummary?: (data: FormInstanceData) => React__default.ReactNode;
    renderActions?: (actions: ActionConfig[]) => React__default.ReactNode;
    onDelete?: () => void;
    onSave?: (values: Record<string, any>) => void;
    components?: Record<string, React__default.ComponentType<any>>;
    inDrawer?: boolean;
}
declare const FormDetailTemplate: React__default.FC<FormDetailTemplateProps>;

interface ProcessDetailTemplateProps {
    schema: FormSchema;
    formUuid: string;
    appType: string;
    formInstanceId: string;
    enableEdit?: boolean;
    enableDelete?: boolean;
    enableChangeRecords?: boolean;
    showApproverInfo?: boolean;
    header?: React__default.ReactNode;
    renderTimeline?: (tasks: ProcessTask[]) => React__default.ReactNode;
    renderActions?: (actions: ProcessAction[]) => React__default.ReactNode;
    renderFooterActions?: (actions: ActionConfig[]) => React__default.ReactNode;
    renderTransferSelector?: (props: {
        value?: string;
        onChange: (userId: string) => void;
    }) => React__default.ReactNode;
    renderReturnNodeLabel?: (node: ReturnableNode) => React__default.ReactNode;
    renderActionModalExtra?: (action: ProcessAction) => React__default.ReactNode;
    beforeForm?: React__default.ReactNode;
    afterForm?: React__default.ReactNode;
    onActionComplete?: (action: string) => Promise<void> | void;
    onSave?: (values: Record<string, any>) => Promise<void> | void;
    onDelete?: () => Promise<void> | void;
    components?: Record<string, React__default.ComponentType<any>>;
    inDrawer?: boolean;
}
declare const ProcessDetailTemplate: React__default.FC<ProcessDetailTemplateProps>;

interface StandardFormPageProps {
    schema: FormSchema;
    mode?: StandardFormPageMode;
    initialValues?: Record<string, any> | null;
    permissions?: FormEngineConfig['permissions'];
    api?: FormEngineConfig['api'];
    formUuid?: string;
    appType?: string;
    formInstanceId?: string;
    defaultUploadProvider?: FormEngineConfig['defaultUploadProvider'];
    submitBehavior?: FormEngineConfig['submitBehavior'];
    compatibility?: FormEngineConfig['compatibility'];
    onSubmit?: (values: Record<string, any>) => Promise<any>;
    onSubmitSuccess?: (formInstId: string) => void;
    components?: Record<string, React__default.ComponentType<any>>;
    inDrawer?: boolean;
}
declare const StandardFormPage: React__default.FC<StandardFormPageProps>;

interface LowcodePageRuntimeContext {
    appType?: string;
    mode?: string;
    compatibility?: {
        apiContracts?: 'strict' | 'legacy';
        legacyFallbacks?: boolean;
    };
    route?: Record<string, any>;
    bridge?: {
        invoke?: (method: string, payload?: any) => Promise<any>;
    };
    [key: string]: any;
}
interface LowcodePageRendererProps {
    schema: LowcodePageSchema;
    context?: LowcodePageRuntimeContext;
}
declare function LowcodePageRenderer({ schema, context }: LowcodePageRendererProps): React__default.JSX.Element;

interface PageSkeletonProps {
    type: 'submit' | 'detail' | 'process';
}
declare const PageSkeleton: React__default.FC<PageSkeletonProps>;

export { type ActionConfig, AddressField, AddressFieldProps, ApprovalActionBar, type ApprovalActionBarProps, ApprovalActions, type ApprovalActionsProps, ApprovalPermission, ApproveParams, AssociationFormField, AssociationFormFieldProps, AttachmentField, AttachmentFieldProps, AttachmentItem, CascadeDateField, CascadeDateFieldProps, CascadeSelectField, CascadeSelectFieldProps, ChangeRecord, ChangeRecordListResponse, ChangeRecordQueryParams, ChangeRecords, type ChangeRecordsProps, CheckboxField, CheckboxFieldProps, ComponentRegistryContext, type ComponentRegistryContextValue, ComponentRegistryProvider, DataManagementConfig, DataManagementConfigScope, DataManagementList, type DataManagementListProps, type DataManagementRowAction, DateField, DateFieldProps, DepartmentSelectField, DepartmentSelectFieldProps, type DeviceDetectResult, DigitalSignatureField, DigitalSignatureFieldProps, DraftManager, type DraftManagerProps, EditorChoiceOption, EditorField, EditorFieldProps, UserSelectField as EmployeeSelectField, FieldBehavior, FieldWrapper, type FieldWrapperProps, FilePreviewCapability, FilePreviewCapabilityError, FilePreviewContent, type FilePreviewContentProps, FilePreviewMetadata, FilePreviewPage, type FilePreviewPageProps, FilePreviewRequest, FormActionBar, type FormActionBarProps, FormActions, type FormActionsProps, FormAppearanceConfig, FormContainer, type FormContainerProps, FormContext, type FormContextValue, FormDataDeleteParams, FormDataQueryParams, FormDetailTemplate, type FormDetailTemplateProps, FormEffect, FormEngineConfig, FormGrid, type FormGridProps, FormInstanceData, FormProvider, type FormProviderProps, FormRenderer, type FormRendererProps, FormRuntimeApi, FormRuntimeApiConfig, FormRuntimeConfig, FormSchema, FormShell, type FormShellProps, type FormStepItem, FormSteps, type FormStepsProps, FormSubmitTemplate, type FormSubmitTemplateProps, FormSummary, FormSummaryCard, type FormSummaryCardProps, type FormSummaryProps, type FormTabItem, FormTabs, type FormTabsProps, ImageField, ImageFieldProps, InitiatorSelectCandidate, InitiatorSelectRequirement, InitiatorSelectedApprovers, JSONField, JSONFieldProps, LocationField, LocationFieldProps, LowcodePageRenderer, type LowcodePageRendererProps, type LowcodePageRuntimeContext, LowcodePageSchema, MultiSelectField, MultiSelectFieldProps, NumberField, NumberFieldProps, OptionItem, OptionSourceConfig, PROCESS_STATUS_META, PageSkeleton, type PageSkeletonProps, PreparedFilePreview, PreviewParams, ProcessAction, ProcessBasicInfo, ProcessDefinition, ProcessDetailTemplate, type ProcessDetailTemplateProps, ProcessRoute, ProcessStatus, ProcessTask, RadioField, RadioFieldProps, RecordChangePanel, type RecordChangePanelProps, ResubmitParams, ReturnParams, ReturnPolicy, ReturnableNode, ReturnableNodeResult, RichTextEditorCore, type RichTextEditorCoreProps, RuntimePageShell, type RuntimePageShellProps, SaveTaskParams, SelectField, SelectFieldProps, SerialNumberField, SerialNumberFieldProps, StandardFormPage, StandardFormPageMode, type StandardFormPageProps, StatusMeta, StickyActionBar, type StickyActionBarProps, SubFormField, SubFormFieldProps, type SubmitConfig, type SubmitSuccessInfo, SummaryPanel, type SummaryPanelMetaItem, type SummaryPanelProps, TASK_STATUS_META, TaskStatus, TextAreaField, TextAreaFieldProps, TextField, TextFieldProps, TextAreaField as TextareaField, TransferParams, type UseApprovalActionsOptions, type UseApprovalActionsReturn, type UseChangeRecordsOptions, type UseChangeRecordsReturn, type UseDraftStorageOptions, type UseDraftStorageReturn, type UseFieldBehaviorOptions, type UseFieldPermissionOptions, type UseFieldPermissionReturn, type UseFormDataReturn, type UseFormDetailOptions, type UseFormDetailReturn, type UseFormEngineReturn, type UseFormNavigationOptions, type UseFormNavigationReturn, type UseFormSubmitReturn, type UseProcessDetailOptions, type UseProcessDetailReturn, UserSelectField, UserSelectFieldProps, VALIDATION_PRESETS, ValidationPreset, ValidationRule, ViewPermissionQueryParams, ViewPermissionSummary, WithdrawParams, checkUserApproval, convertHeicPreview, createFormRuntimeApi, decodeHtmlEntities, defaultComponentRegistry, defineFormSchema, deleteFormData, evaluateEffects, extractFormValues, formatPreviewFileSize, getChangeRecords, getFormData, getInitiatorSelectCandidates, getInitiatorSelectRequirements, getPreviewItemKey, getPreviewSourceUrl, getProcessBasic, getProcessDefinition, getProcessProgress, getResubmitInitiatorSelectRequirements, getReturnableNodeResult, getReturnableNodes, getViewPermission, handleApproval, hasViewOperation, hasViewPermission, isDirectStorageItem, loadPreviewBlob, normalizeFieldBehaviors, normalizeOperation, normalizePreviewBlobContent, normalizePreviewBlobResponse, normalizeRichTextHtml, prepareFilePreview, previewProcess, resolveDefaultValueLinkage, resolveLocalPreviewCapability, resolveOptions, resolvePreviewServiceUrl, resubmitTask, returnTask, sanitizeRichTextHtml, saveTask, transferTask, triggerCallbackTask, unwrapFilePreviewPayload, useApprovalActions, useChangeRecords, useComponent, useDeviceDetect, useDraftStorage, useFieldBehavior, useFieldPermission, useFilePreviewController, useFormContext, useFormData, useFormDetail, useFormEngine, useFormNavigation, useFormSubmit, useProcessDetail, validateAllFields, validateField, withdrawProcess };