@dataverse-kit/form-runtime 0.1.0

package/dist/types.d.cts

@@ -0,0 +1,813 @@
+import { Y as FormType } from './control-DFOg_pc_.cjs';
+export { A as AuditFormTab, a as AuditHistoryConfig, B as ButtonAction, b as ButtonCommandBarItem, c as ButtonConfig, d as ButtonMenuItem, e as ButtonSize, f as ButtonVariant, C as CalloutActionButton, g as CalloutAttachment, h as CalloutDefinition, i as CalloutDirectionalHint, j as CalloutFieldBinding, k as CalloutTargetType, l as CalloutTrigger, m as ChartAggregation, n as ChartConfig, o as ChartPalette, p as ComboBoxConfig, q as CommandBarItem, r as CommandBarItemActionScope, s as CommandBarItemActionType, t as CommandBarItemPosition, u as CommandBarItemVisibility, v as ControlCategory, w as ControlDataBinding, x as ControlDefinition, y as ControlRegistryEntry, z as ControlType, D as CustomOptionItem, E as DEFAULT_FORM_GRID_LAYOUT, F as DialogActionButton, G as DialogButtonAction, H as DialogButtonAppearance, I as DialogButtonPosition, J as DropdownConfig, K as FetchXmlAggregateFunction, L as FetchXmlAttribute, M as FormCell, N as FormDataSource, O as FormDefinition, P as FormGridLayout, Q as FormHeader, R as FormLayoutMode, S as FormParameter, T as FormRow, U as FormSection, V as FormSectionGridPosition, W as FormSettings, X as FormTab, Z as HeaderDisplayMode, _ as HeaderPersonaColor, $ as HeaderPersonaConfig, a0 as HeaderPersonaSize, a1 as HeaderPersonaSourceMode, a2 as HeaderSlotCount, a3 as LayoutActionEntry, a4 as LayoutActionType, a5 as MainFormTab, a6 as NavigationAction, a7 as NavigationActionType, a8 as NavigationCloseResult, a9 as NavigationContext, aa as NavigationOnCloseConfig, ab as NavigationSizeConfig, ac as NavigationStackEntry, ad as OptionSourceMode, ae as PRIMARY_CAPABLE_VARIANTS, af as PanelPosition, ag as ParameterMapping, ah as ParameterSourceType, ai as RelatedFormTab, aj as RelatedTabConfig, ak as ResponsiveSettings, al as SubgridColumn, am as SubgridColumnDataType, an as SubgridGridType, ao as TabLayout, ap as TextFieldConfig, aq as TextFormat, ar as ValidationRule, as as isAuditTab, at as isMainTab, au as isRelatedTab } from './control-DFOg_pc_.cjs';
+export { B as BackgroundConfig, D as DEFAULT_THEME, F as FormTheme, a as FormThemeColors, b as FormThemeSettings, G as GradientStop, S as STANDARD_COLORS, T as THEME_PRESETS, g as getResolvedThemeColors, c as getThemeById } from './theme-BfeZIxmZ.cjs';
+export { A as AggregateFunction, C as CellEditorType, a as CellRendererType, b as CompositeRendererConfig, c as CompositeSlot, d as CompositeSlotType, e as ConditionalStyle, F as FOCUSED_VIEW_ICON_OPTIONS, f as FocusedViewConfig, g as FocusedViewField, h as FocusedViewRow, G as GridCardViewConfig, i as GridChartConfig, j as GridColumnDataType, k as GridColumnDefinition, l as GridColumnInput, m as GridCustomizerDefinition, n as GridFocusedViewSettings, o as GridNestedRelationship, p as GridPaginationMode, q as GridSelectionMode, r as GridToolbarButton, s as GridToolbarConfig, t as GridType, L as LegacySummaryField, u as LookupPreviewConfig, M as MAX_FOCUSED_VIEW_ROWS, N as NestedDisplayConfig, v as NestedDisplayMode, w as NestedSidePanelSize, x as createConfigFromColumns, y as createDefaultCardViewConfig, z as createDefaultCompositeRendererConfig, B as createDefaultCompositeSlot, D as createDefaultFocusedViewConfig, E as createDefaultGridColumn, H as createDefaultGridCustomizer, I as createDefaultToolbarConfig, J as generateGridId, K as isValidFocusedViewConfig, O as migrateLegacyConfig } from './gridCustomizer-mJO-kmQ4.cjs';
+import { m as RuleConditionGroup, R as RuleAction, f as ConditionOperator, g as ConditionValue } from './businessRules-U1_MBgyG.cjs';
+export { A as ActionConfig, a as ActionResult, b as ActionTarget, c as ApiParameter, B as BusinessRuleDefinition, C as CallApiConfig, d as CanvasConnection, e as CanvasNode, h as CrudBlockConfig, F as FieldState, i as FormNotification, N as NavigateToFormConfig, O as OpenDialogConfig, P as PreventSaveConfig, j as RuleActionType, k as RuleCanvasLayout, l as RuleCondition, n as RuleDataSource, o as RuleExecutionContext, p as RuleExecutionResult, q as RuleTrigger, r as RuleVariable, S as SectionState, s as SetDefaultValueConfig, t as SetFieldValueConfig, u as SetFormNotificationConfig, v as SetFormReadOnlyConfig, w as SetHighlightConfig, x as SetLockConfig, y as SetRequiredConfig, z as SetVisibilityConfig, D as ShowMessageConfig, T as TabState, E as TriggerEvent, G as TriggerWorkflowConfig, W as WorkflowDefinition, H as WorkflowResult, I as WorkflowStep, J as WorkflowStepResult, K as createDefaultBusinessRule, L as createDefaultFieldState, M as getActionTargets, Q as isConditionGroup } from './businessRules-U1_MBgyG.cjs';
+export { F as FormRuntimeCapabilities, a as FormRuntimeConnection, b as FormRuntimePreviewContext, L as LiveDataResult, c as LookupResult, d as LookupSearchOptions, T as TimelineItem, W as WebResourceData } from './runtime-capabilities-BdGDdu0d.cjs';
+
+/**
+ * Dataverse metadata types — declarations only.
+ *
+ * Originally re-exported from `@dataverse-kit/api-client`. Inlined here
+ * so form-runtime stays a self-contained type peer for `@dataverse-kit/api-service`
+ * (which already exposes `EntityMetadata`, `AttributeMetadata`, `ViewMetadata`)
+ * without form-runtime needing api-client as a peer dep.
+ *
+ * TODO (cleanup PR): consolidate `EntityMetadata` / `AttributeMetadata` /
+ * `ViewMetadata` between api-service and form-runtime — pick one origin
+ * and have the other re-export. Today both packages declare them
+ * independently. Relationship + global-option-set types are form-runtime
+ * specific (api-service does not declare them).
+ */
+interface DisplayNameInfo {
+    UserLocalizedLabel?: {
+        Label: string;
+        LanguageCode?: number;
+    };
+    LocalizedLabels?: Array<{
+        Label: string;
+        LanguageCode?: number;
+    }>;
+}
+/** Entity metadata from Dataverse EntityDefinitions. */
+interface EntityMetadata {
+    LogicalName: string;
+    EntitySetName: string;
+    SchemaName: string;
+    DisplayName: DisplayNameInfo;
+    DisplayCollectionName: DisplayNameInfo;
+    PrimaryIdAttribute: string;
+    PrimaryNameAttribute: string;
+    IsCustomEntity: boolean;
+    IsActivity: boolean;
+    IsValidForAdvancedFind: boolean;
+    ObjectTypeCode?: number;
+    Description?: DisplayNameInfo;
+}
+/** Attribute metadata from Dataverse. */
+interface AttributeMetadata {
+    LogicalName: string;
+    SchemaName: string;
+    DisplayName: DisplayNameInfo;
+    Description?: DisplayNameInfo;
+    AttributeType: string;
+    AttributeTypeName: {
+        Value: string;
+    };
+    RequiredLevel: {
+        Value: 'None' | 'SystemRequired' | 'ApplicationRequired' | 'Recommended';
+    };
+    IsValidForRead: boolean;
+    IsValidForCreate: boolean;
+    IsValidForUpdate: boolean;
+    IsPrimaryId?: boolean;
+    IsPrimaryName?: boolean;
+    MaxLength?: number;
+    Precision?: number;
+    MinValue?: number;
+    MaxValue?: number;
+    Format?: string;
+    FormatName?: {
+        Value: string;
+    };
+    OptionSet?: {
+        Options: Array<{
+            Value: number;
+            Label: DisplayNameInfo;
+            Color?: string;
+        }>;
+        IsGlobal?: boolean;
+        Name?: string;
+    };
+    GlobalOptionSet?: {
+        Options: Array<{
+            Value: number;
+            Label: DisplayNameInfo;
+            Color?: string;
+        }>;
+        IsGlobal?: boolean;
+        Name?: string;
+    };
+    DateTimeBehavior?: {
+        Value: string;
+    };
+    Targets?: string[];
+}
+/** View metadata from Dataverse. */
+interface ViewMetadata {
+    id: string;
+    name: string;
+    fetchxml: string;
+    layoutxml?: string;
+    isDefault?: boolean;
+    isPersonal: boolean;
+    returnedtypecode: string;
+    description?: string;
+}
+/** Relationship type discriminator. */
+type RelationshipType = 'OneToMany' | 'ManyToOne';
+interface OneToManyRelationshipMetadata {
+    MetadataId: string;
+    SchemaName: string;
+    RelationshipType: 'OneToManyRelationship';
+    ReferencedEntity: string;
+    ReferencedAttribute: string;
+    ReferencingEntity: string;
+    ReferencingAttribute: string;
+    IsCustomRelationship?: boolean;
+    ReferencingEntityNavigationPropertyName?: string;
+    ReferencedEntityNavigationPropertyName?: string;
+}
+interface ManyToOneRelationshipMetadata {
+    MetadataId: string;
+    SchemaName: string;
+    RelationshipType: 'ManyToOneRelationship';
+    ReferencedEntity: string;
+    ReferencedAttribute: string;
+    ReferencingEntity: string;
+    ReferencingAttribute: string;
+    IsCustomRelationship?: boolean;
+    ReferencingEntityNavigationPropertyName?: string;
+    ReferencedEntityNavigationPropertyName?: string;
+}
+type RelationshipMetadata = OneToManyRelationshipMetadata | ManyToOneRelationshipMetadata;
+/** Normalized relationship for UI display. */
+interface NormalizedRelationship {
+    key: string;
+    schemaName: string;
+    displayName: string;
+    relatedEntity: string;
+    primaryField: string;
+    relatedField: string;
+    direction: 'parent' | 'child';
+    relationshipType: RelationshipType;
+}
+/** Option within a global option set. */
+interface GlobalOptionSetOption {
+    Value: number;
+    Label: DisplayNameInfo;
+    Description?: DisplayNameInfo;
+    Color?: string;
+}
+/** Global option set metadata from Dataverse. */
+interface GlobalOptionSetMetadata {
+    MetadataId: string;
+    Name: string;
+    DisplayName: DisplayNameInfo;
+    Description?: DisplayNameInfo;
+    IsCustomOptionSet: boolean;
+    IsGlobal: boolean;
+    IsManaged?: boolean;
+    OptionSetType: 'Picklist' | 'Boolean' | 'State' | 'Status';
+    Options: GlobalOptionSetOption[];
+}
+/**
+ * Unified Dataverse client interface (CRUD + metadata + views).
+ *
+ * Form-runtime hooks consume `IApiService` (from `@dataverse-kit/api-service`)
+ * rather than this interface directly, but the type stays in the public
+ * surface because some consumers of `form-runtime/types` still hand off
+ * the lower-level client (e.g., view-management tooling in the editor).
+ */
+interface IDataverseClient {
+    retrieve<T = Record<string, unknown>>(entitySetName: string, id: string, options?: string): Promise<T>;
+    retrieveMultiple<T = Record<string, unknown>>(entitySetName: string, options?: string): Promise<{
+        value: T[];
+    }>;
+    create(entitySetName: string, data: Record<string, unknown>): Promise<{
+        id: string;
+    }>;
+    update(entitySetName: string, id: string, data: Record<string, unknown>): Promise<void>;
+    delete(entitySetName: string, id: string): Promise<void>;
+    getEntityDefinitions(filter?: string): Promise<EntityMetadata[]>;
+    getAttributeMetadata(entityLogicalName: string, filter?: string): Promise<AttributeMetadata[]>;
+    getRelationshipMetadata(entityLogicalName: string): Promise<RelationshipMetadata[]>;
+    getViews(entityLogicalName: string): Promise<ViewMetadata[]>;
+    getGlobalOptionSets(): Promise<GlobalOptionSetMetadata[]>;
+}
+
+/**
+ * Business Process Flow Type Definitions
+ *
+ * Models the BPF structure matching Dynamics 365's process flow system.
+ * Supports both importing existing BPFs from Dataverse and creating custom ones.
+ *
+ * Design principles:
+ * - Matches Dynamics 365 BPF structure (workflow, processstage, processstageattribute)
+ * - Reuses RuleConditionGroup and RuleAction from businessRules for conditions/actions
+ * - Supports runtime instance tracking per record
+ * - JSON-serializable for persistence
+ */
+
+/** BPF source - imported from Dataverse or created custom */
+type BPFSource = 'dataverse' | 'custom';
+/** Stage completion status */
+type BPFStageStatus = 'pending' | 'active' | 'completed' | 'skipped';
+/** Step types matching Dynamics 365 BPF step types */
+type BPFStepType = 'data' | 'workflow' | 'action' | 'flow';
+/** Field types for data steps - determines input control in callout */
+type BPFStepFieldType = 'text' | 'textarea' | 'number' | 'decimal' | 'currency' | 'date' | 'datetime' | 'lookup' | 'optionset' | 'multiselect' | 'boolean' | 'owner';
+/** Represents a connection between stages (or from condition nodes) */
+interface BPFEdge {
+    /** Unique identifier */
+    id: string;
+    /** Source stage ID (or condition node ID) */
+    fromStageId: string;
+    /** Target stage ID */
+    toStageId: string;
+    /** Optional condition - if set, edge is only taken when condition evaluates true */
+    condition?: RuleConditionGroup;
+    /** Label for the edge (e.g., "Yes", "No", "Approved") */
+    label?: string;
+    /** Evaluation order when multiple edges from same source (lower = evaluated first) */
+    order?: number;
+    /** Whether this is the default/fallback edge when no conditions match */
+    isDefault?: boolean;
+}
+/** A condition branch point in the BPF (the purple diamond in Dynamics) */
+interface BPFConditionNode {
+    /** Unique identifier */
+    id: string;
+    /** Display name (e.g., "Met Budget?") */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** The condition to evaluate (determines which outgoing edge to take) */
+    condition: RuleConditionGroup;
+    /** Position for visual layout */
+    position?: {
+        x: number;
+        y: number;
+    };
+}
+/** 2D position for flowchart layout */
+interface BPFNodePosition {
+    x: number;
+    y: number;
+}
+/** A step within a BPF stage */
+interface BPFStep {
+    /** Unique identifier */
+    id: string;
+    /** Step name/label */
+    name: string;
+    /** Display order within stage (1-based) */
+    order: number;
+    /** Step type */
+    type: BPFStepType;
+    /** Whether this step must be completed to advance */
+    required: boolean;
+    /** Optional description */
+    description?: string;
+    /** For data steps - field logical name to fill */
+    fieldLogicalName?: string;
+    /** For data steps - field display name */
+    fieldDisplayName?: string;
+    /** For data steps - field type (determines input control) */
+    fieldType?: BPFStepFieldType;
+    /** For optionset fields - available options */
+    options?: Array<{
+        value: string | number;
+        label: string;
+    }>;
+    /** For lookup fields - target entity */
+    lookupTargetEntity?: string;
+    /** For lookup fields - additional target entities (polymorphic lookups like Customer) */
+    lookupTargetEntities?: string[];
+    /** For lookup fields - OData filter expression (e.g., "statecode eq 0") */
+    lookupFilter?: string;
+    /** For lookup fields - custom FetchXML for advanced filtering */
+    lookupFetchXml?: string;
+    /** For lookup fields - view ID to use for filtering (uses view's FetchXML) */
+    lookupViewId?: string;
+    /** For lookup fields - whether to allow creating new records inline */
+    lookupAllowCreate?: boolean;
+    /** For lookup fields - columns to display in search results */
+    lookupDisplayColumns?: string[];
+    /** For workflow steps - workflow ID */
+    workflowId?: string;
+    /** For workflow steps - workflow name */
+    workflowName?: string;
+    /** For action steps - action ID */
+    actionId?: string;
+    /** For action steps - action name */
+    actionName?: string;
+    /** For Power Automate flow steps - flow ID */
+    flowId?: string;
+    /** For Power Automate flow steps - flow name */
+    flowName?: string;
+    /** Dataverse process stage attribute ID (for imported BPFs) */
+    dataverseAttributeId?: string;
+}
+/** A stage in the BPF */
+interface BPFStage {
+    /** Unique identifier */
+    id: string;
+    /** Stage name/label */
+    name: string;
+    /** Display order (1-based) */
+    order: number;
+    /** Current status (runtime) */
+    status: BPFStageStatus;
+    /** Optional description */
+    description?: string;
+    /** Fluent UI icon name */
+    icon?: string;
+    /** Custom color (hex) */
+    color?: string;
+    /** Steps within this stage */
+    steps: BPFStep[];
+    /** Conditions required to enter this stage */
+    entryCondition?: RuleConditionGroup;
+    /** Conditions required to exit this stage */
+    exitCondition?: RuleConditionGroup;
+    /** Actions to execute when entering this stage */
+    onEnterActions?: RuleAction[];
+    /** Actions to execute when exiting this stage */
+    onExitActions?: RuleAction[];
+    /** Link to a form to show for this stage */
+    linkedFormId?: string;
+    /** Dataverse process stage ID (for imported BPFs) */
+    dataverseStageId?: string;
+    /** Dataverse stage category (for imported BPFs) */
+    dataverseStageCategory?: number;
+    /** Position for flowchart layout (used when edges are present) */
+    position?: BPFNodePosition;
+}
+/** Complete BPF definition */
+interface BusinessProcessFlowDefinition {
+    /** Unique identifier */
+    id: string;
+    /** BPF name */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Entity this BPF applies to */
+    entityLogicalName: string;
+    /** Entity display name */
+    entityDisplayName?: string;
+    /** Whether imported from Dataverse or created custom */
+    source: BPFSource;
+    /** Dataverse workflow ID (for imported BPFs) */
+    dataverseWorkflowId?: string;
+    /** Dataverse unique name (for imported BPFs) */
+    dataverseUniqueName?: string;
+    /** Ordered list of stages */
+    stages: BPFStage[];
+    /**
+     * Edges connecting stages/condition nodes.
+     * If present, navigation uses edge traversal instead of index arithmetic.
+     * Empty or undefined = linear navigation (backward compatible).
+     */
+    edges?: BPFEdge[];
+    /**
+     * Condition branch points (purple diamonds in Dynamics designer).
+     * Referenced by edges via their IDs.
+     */
+    conditionNodes?: BPFConditionNode[];
+    /** Currently active stage index (0-based, -1 if not started) */
+    activeStageIndex: number;
+    /** Whether this BPF is active */
+    isActive: boolean;
+    /** Allow navigating to previous stages */
+    allowBackNavigation: boolean;
+    /** Show stage labels in progress indicator */
+    showStageLabels: boolean;
+    /** Progress indicator variant */
+    progressVariant?: 'chevron' | 'circle' | 'minimal';
+    /** BPF-wide accent color applied to all stages (individual stage.color overrides) */
+    accentColor?: string;
+    /** ISO timestamp when created */
+    createdAt: string;
+    /** ISO timestamp when last updated */
+    updatedAt: string;
+    /** Creator user ID */
+    createdBy?: string;
+}
+/** Runtime instance of a BPF for a specific record */
+interface BPFInstance {
+    /** Instance ID */
+    id: string;
+    /** Reference to the BPF definition */
+    bpfDefinitionId: string;
+    /** Record ID this instance is tracking */
+    recordId: string;
+    /** Entity logical name of the record */
+    entityLogicalName: string;
+    /** Current active stage ID */
+    activeStageId: string;
+    /** IDs of completed stages */
+    completedStageIds: string[];
+    /** IDs of skipped stages */
+    skippedStageIds: string[];
+    /** IDs of completed steps (across all stages) */
+    completedStepIds: string[];
+    /**
+     * Path history - ordered list of stage/node IDs visited.
+     * Used for tracking non-linear traversal in branching BPFs.
+     */
+    pathHistory?: string[];
+    /** When the BPF was started for this record */
+    startedAt: string;
+    /** When the BPF was completed (all stages done) */
+    completedAt?: string;
+    /** Dataverse process instance ID */
+    dataverseInstanceId?: string;
+}
+/** Dataverse BPF metadata from workflow entity */
+interface DataverseBPFMetadata {
+    /** Workflow ID (GUID) */
+    workflowId: string;
+    /** BPF name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Primary entity logical name */
+    primaryEntity: string;
+    /** Category (4 = Business Process Flow) */
+    category: number;
+    /** State code (1 = Activated) */
+    stateCode: number;
+    /** Status code */
+    statusCode: number;
+    /** Unique name */
+    uniqueName?: string;
+    /** Stages within this BPF */
+    stages: DataverseBPFStageMetadata[];
+    /** Branch data (for branching BPFs) */
+    branchData?: DataverseBPFBranchData;
+}
+/** Dataverse attribute types */
+type DataverseAttributeType = 'String' | 'Memo' | 'Integer' | 'BigInt' | 'Decimal' | 'Double' | 'Money' | 'DateTime' | 'Boolean' | 'Lookup' | 'Owner' | 'Customer' | 'Picklist' | 'State' | 'Status' | 'MultiSelectPicklist' | 'Uniqueidentifier' | 'Image' | 'File' | 'EntityName' | 'Virtual' | 'ManagedProperty' | 'PartyList';
+/** Parsed step info from clientdata */
+interface DataverseBPFStepInfo {
+    /** Field logical name (e.g., "parentcontactid") */
+    controlId: string;
+    /** Display name/label (e.g., "Existing Contact") */
+    displayName: string;
+    /** Whether this step is required to advance */
+    isRequired?: boolean;
+    /** Attribute type from Dataverse (e.g., "Lookup", "Picklist", "Money") */
+    attributeType?: DataverseAttributeType;
+    /** For lookup fields - target entity logical names */
+    lookupTargets?: string[];
+    /** For optionset fields - available options */
+    options?: Array<{
+        value: number;
+        label: string;
+    }>;
+    /** Format hint (e.g., "Phone", "Email", "Url" for String attributes) */
+    format?: string;
+    /** Max length for string fields */
+    maxLength?: number;
+    /** Precision for decimal/currency fields */
+    precision?: number;
+}
+/** Dataverse process stage metadata */
+interface DataverseBPFStageMetadata {
+    /** Process stage ID (GUID) */
+    stageId: string;
+    /** Stage name */
+    name: string;
+    /** Stage category (order indicator) */
+    stageCategory: number;
+    /** Primary entity for this stage */
+    primaryEntityLogicalName: string;
+    /** Required attributes (field logical names) - legacy */
+    requiredAttributes: string[];
+    /** Parsed step info with both controlId and displayName */
+    parsedSteps?: DataverseBPFStepInfo[];
+    /** Process ID this stage belongs to */
+    processId: string;
+}
+/** Branch connection from clientdata */
+interface DataverseBPFBranchInfo {
+    /** Source stage or condition node ID */
+    fromNodeId: string;
+    /** Target stage ID */
+    toStageId: string;
+    /** Branch label (e.g., "Yes", "No") */
+    label?: string;
+    /** Condition expression (raw from Dynamics) */
+    conditionExpression?: string;
+    /** Parsed condition field */
+    conditionField?: string;
+    /** Parsed condition operator */
+    conditionOperator?: string;
+    /** Parsed condition value */
+    conditionValue?: unknown;
+    /** Whether this is the default/else branch */
+    isDefault?: boolean;
+    /** Branch order (for evaluation priority) */
+    order?: number;
+}
+/** Condition node from clientdata (the decision point) */
+interface DataverseBPFConditionInfo {
+    /** Condition node ID */
+    nodeId: string;
+    /** Display name (e.g., "Met Budget?") */
+    name: string;
+    /** The field being evaluated */
+    conditionField?: string;
+    /** The operator (eq, ne, gt, etc.) */
+    conditionOperator?: string;
+    /** The value being compared */
+    conditionValue?: unknown;
+    /** Raw condition expression */
+    conditionExpression?: string;
+    /** Stage ID this condition belongs to (the "parent" stage) */
+    parentStageId?: string;
+}
+/** Extended BPF metadata with branching info */
+interface DataverseBPFBranchData {
+    /** Branch connections */
+    branches: DataverseBPFBranchInfo[];
+    /** Condition nodes (decision points) */
+    conditionNodes: DataverseBPFConditionInfo[];
+    /** Whether this BPF has branching */
+    hasBranching: boolean;
+}
+/** Result of a stage navigation attempt */
+interface BPFNavigationResult {
+    /** Whether navigation succeeded */
+    success: boolean;
+    /** New active stage ID (if successful) */
+    newActiveStageId?: string;
+    /** Error message (if failed) */
+    error?: string;
+    /** Validation errors preventing navigation */
+    validationErrors?: BPFValidationError[];
+}
+/** Validation error for BPF operations */
+interface BPFValidationError {
+    /** Stage ID where error occurred */
+    stageId?: string;
+    /** Step ID where error occurred */
+    stepId?: string;
+    /** Error message */
+    message: string;
+    /** Error type */
+    type: 'required-step' | 'exit-condition' | 'entry-condition' | 'workflow-failed';
+}
+/** Create a default BPF step */
+declare function createDefaultBPFStep(type?: BPFStepType, order?: number): BPFStep;
+/** Create a default BPF stage */
+declare function createDefaultBPFStage(order?: number): BPFStage;
+/** Create a default BPF edge */
+declare function createDefaultBPFEdge(fromStageId: string, toStageId: string, options?: {
+    label?: string;
+    condition?: RuleConditionGroup;
+    isDefault?: boolean;
+    order?: number;
+}): BPFEdge;
+/** Create a default BPF condition node */
+declare function createDefaultBPFConditionNode(name?: string, condition?: RuleConditionGroup): BPFConditionNode;
+/** Create a default BPF definition */
+declare function createDefaultBPF(entityLogicalName: string, name?: string): BusinessProcessFlowDefinition;
+/** Create a BPF instance for a record */
+declare function createBPFInstance(bpf: BusinessProcessFlowDefinition, recordId: string): BPFInstance;
+/** Convert Dataverse BPF metadata to BPF definition */
+declare function convertDataverseBPFToDefinition(metadata: DataverseBPFMetadata): BusinessProcessFlowDefinition;
+/** Step type display information */
+declare const BPF_STEP_TYPES: Record<BPFStepType, {
+    label: string;
+    icon: string;
+    description: string;
+}>;
+/** Stage status display information */
+declare const BPF_STAGE_STATUSES: Record<BPFStageStatus, {
+    label: string;
+    icon: string;
+    color: string;
+}>;
+/** Condition node display information */
+declare const BPF_CONDITION_NODE_DISPLAY: {
+    label: string;
+    icon: string;
+    color: string;
+    shape: string;
+};
+/** Edge display information */
+declare const BPF_EDGE_DISPLAY: {
+    defaultLabel: string;
+    yesLabel: string;
+    noLabel: string;
+    defaultColor: string;
+    conditionalColor: string;
+};
+/**
+ * Check if a BPF uses edge-based branching.
+ * Returns false for linear BPFs (backward compatible).
+ */
+declare function hasBranching(bpf: BusinessProcessFlowDefinition): boolean;
+/**
+ * Get outgoing edges from a stage or condition node.
+ */
+declare function getOutgoingEdges(bpf: BusinessProcessFlowDefinition, nodeId: string): BPFEdge[];
+/**
+ * Get incoming edges to a stage or condition node.
+ */
+declare function getIncomingEdges(bpf: BusinessProcessFlowDefinition, nodeId: string): BPFEdge[];
+/**
+ * Get condition node by ID.
+ */
+declare function getConditionNodeById(bpf: BusinessProcessFlowDefinition, nodeId: string): BPFConditionNode | undefined;
+/**
+ * Check if a node ID is a condition node (vs a stage).
+ */
+declare function isConditionNode(bpf: BusinessProcessFlowDefinition, nodeId: string): boolean;
+/**
+ * Get the default (fallback) edge from a node.
+ */
+declare function getDefaultEdge(bpf: BusinessProcessFlowDefinition, nodeId: string): BPFEdge | undefined;
+
+/**
+ * Form Selector Types
+ *
+ * Defines types for Dynamics 365-style form switching functionality:
+ * - Form grouping by entity (like D365 form selector dropdown)
+ * - Form selection rules (auto-select based on conditions)
+ * - Entity-based sidebar organization
+ * - Default form per entity
+ */
+
+/** Lightweight form reference for dropdowns and lists */
+interface FormSummary {
+    id: string;
+    name: string;
+    type: FormType;
+    entityLogicalName?: string;
+    isDefault?: boolean;
+    order?: number;
+    description?: string;
+    /** Number of embedded callouts on this form */
+    calloutCount?: number;
+}
+/**
+ * Determines which form to display based on conditions.
+ * Rules are evaluated in priority order; first match wins.
+ */
+interface FormSelectorRule {
+    id: string;
+    name: string;
+    /** Entity this rule applies to */
+    entityLogicalName: string;
+    /** Form type this rule applies to (e.g., only 'main' forms) */
+    formType: FormType;
+    /** The form to show when this rule matches */
+    targetFormId: string;
+    /** Condition tree that determines when this rule applies */
+    condition: RuleConditionGroup;
+    /** Evaluation order (lower = higher priority) */
+    priority: number;
+    /** Whether this rule is active */
+    enabled: boolean;
+    /** Metadata */
+    createdAt: string;
+    updatedAt: string;
+}
+/** Type of condition for form selection */
+type FormSelectorConditionType = 'field-value' | 'security-role' | 'business-unit' | 'team' | 'form-context' | 'record-type' | 'custom';
+/** Condition for checking user's security role */
+interface SecurityRoleCondition {
+    type: 'security-role';
+    roleId?: string;
+    roleName?: string;
+    operator: 'has-role' | 'not-has-role';
+}
+/** Condition for checking user's business unit */
+interface BusinessUnitCondition {
+    type: 'business-unit';
+    businessUnitId?: string;
+    businessUnitName?: string;
+    operator: 'in-bu' | 'not-in-bu' | 'in-bu-hierarchy';
+}
+/** Condition for checking form context */
+interface FormContextCondition {
+    type: 'form-context';
+    context: 'is-create-mode' | 'is-update-mode' | 'is-mobile' | 'is-tablet' | 'is-desktop' | 'is-offline' | 'is-quick-create';
+}
+/** Condition for checking field values */
+interface FieldValueCondition {
+    type: 'field-value';
+    fieldName: string;
+    operator: ConditionOperator;
+    value?: ConditionValue;
+    compareToField?: string;
+}
+/** Union of all form selector condition types */
+type FormSelectorCondition = SecurityRoleCondition | BusinessUnitCondition | FormContextCondition | FieldValueCondition;
+/**
+ * Computed grouping of forms by entity.
+ * Derived from FormDefinition[] - not stored directly.
+ */
+interface EntityFormGroup {
+    /** Entity logical name (e.g., "contact", "account") */
+    entityLogicalName: string;
+    /** Display name for the entity (from form data binding) */
+    entityDisplayName: string;
+    /** Icon name for the entity (optional) */
+    entityIcon?: string;
+    /** Forms grouped by their type */
+    formsByType: Partial<Record<FormType, FormSummary[]>>;
+    /** Total number of forms for this entity */
+    totalForms: number;
+    /** ID of the default main form for this entity */
+    defaultMainFormId?: string;
+    /** Form selector rules for this entity */
+    rules: FormSelectorRule[];
+}
+/**
+ * Group for forms without entity binding.
+ * These are typically dialogs, panels, or utility forms.
+ */
+interface UnboundFormGroup {
+    /** Forms grouped by their type */
+    formsByType: Partial<Record<FormType, FormSummary[]>>;
+    /** Total number of unbound forms */
+    totalForms: number;
+}
+/**
+ * Runtime context for selecting a form.
+ * Passed to the form selection engine.
+ */
+interface FormSelectionContext {
+    /** Current user's security roles */
+    userRoles?: string[];
+    /** Current user's business unit ID */
+    userBusinessUnitId?: string;
+    /** Current user's team IDs */
+    userTeamIds?: string[];
+    /** Whether creating a new record */
+    isCreateMode?: boolean;
+    /** Whether updating an existing record */
+    isUpdateMode?: boolean;
+    /** Client type */
+    clientType?: 'web' | 'mobile' | 'tablet';
+    /** Whether offline */
+    isOffline?: boolean;
+    /** Whether quick create mode */
+    isQuickCreate?: boolean;
+    /** Current record data (for field-value conditions) */
+    recordData?: Record<string, unknown>;
+    /** Explicitly requested form ID (overrides rules) */
+    requestedFormId?: string;
+}
+/**
+ * Result of form selection.
+ * Indicates which form was selected and why.
+ */
+interface FormSelectionResult {
+    /** The selected form ID */
+    formId: string;
+    /** Form name for display */
+    formName: string;
+    /** How the form was selected */
+    selectionReason: 'explicit-request' | 'rule-match' | 'default-form' | 'first-available';
+    /** If selected by rule, the rule that matched */
+    matchedRuleId?: string;
+    matchedRuleName?: string;
+    /** Other forms available for this entity */
+    alternativeForms: FormSummary[];
+}
+/** How forms are organized in the sidebar */
+type SidebarViewMode = 'by-type' | 'by-entity';
+/**
+ * Information about forms linked by sharing the same entity.
+ * Used in properties panel to show linked forms.
+ */
+interface LinkedFormsInfo {
+    /** Entity logical name */
+    entityLogicalName: string;
+    /** Entity display name */
+    entityDisplayName: string;
+    /** Other forms that share this entity */
+    linkedForms: FormSummary[];
+    /** Associated BPF (if any) */
+    bpfId?: string;
+    bpfName?: string;
+}
+/** Creates a new form selector rule with defaults */
+declare function createFormSelectorRule(entityLogicalName: string, targetFormId: string, name?: string): FormSelectorRule;
+/** Converts a FormDefinition to a FormSummary */
+declare function toFormSummary(form: {
+    id: string;
+    name: string;
+    type: FormType;
+    settings?: {
+        dataSources?: {
+            entityName?: string;
+        }[];
+        isDefaultForEntity?: boolean;
+    };
+    order?: number;
+    description?: string;
+    callouts?: unknown[];
+}): FormSummary;
+/** Map of common entity names to Fluent UI icons */
+declare const entityIconMap: Record<string, string>;
+/** Get icon for an entity, with fallback */
+declare function getEntityIcon(entityLogicalName: string): string;
+
+export { type AttributeMetadata, type BPFConditionNode, type BPFEdge, type BPFInstance, type BPFNavigationResult, type BPFNodePosition, type BPFSource, type BPFStage, type BPFStageStatus, type BPFStep, type BPFStepFieldType, type BPFStepType, type BPFValidationError, BPF_CONDITION_NODE_DISPLAY, BPF_EDGE_DISPLAY, BPF_STAGE_STATUSES, BPF_STEP_TYPES, type BusinessProcessFlowDefinition, type BusinessUnitCondition, ConditionOperator, ConditionValue, type DataverseAttributeType, type DataverseBPFBranchData, type DataverseBPFBranchInfo, type DataverseBPFConditionInfo, type DataverseBPFMetadata, type DataverseBPFStageMetadata, type DataverseBPFStepInfo, type DisplayNameInfo, type EntityFormGroup, type EntityMetadata, type FieldValueCondition, type FormContextCondition, type FormSelectionContext, type FormSelectionResult, type FormSelectorCondition, type FormSelectorConditionType, type FormSelectorRule, type FormSummary, FormType, type GlobalOptionSetMetadata, type GlobalOptionSetOption, type IDataverseClient, type LinkedFormsInfo, type ManyToOneRelationshipMetadata, type NormalizedRelationship, type OneToManyRelationshipMetadata, type RelationshipMetadata, type RelationshipType, RuleAction, RuleConditionGroup, type SecurityRoleCondition, type SidebarViewMode, type UnboundFormGroup, type ViewMetadata, convertDataverseBPFToDefinition, createBPFInstance, createDefaultBPF, createDefaultBPFConditionNode, createDefaultBPFEdge, createDefaultBPFStage, createDefaultBPFStep, createFormSelectorRule, entityIconMap, getConditionNodeById, getDefaultEdge, getEntityIcon, getIncomingEdges, getOutgoingEdges, hasBranching, isConditionNode, toFormSummary };