import { __name } from "../_virtual/_rolldown/runtime.mjs";
import { BaseEdge, BaseEdgeData, BaseEdgeProps, BaseNode, BaseNodeData, BaseNodeProps, NonOptional } from "../base/types.mjs";
import { FunctionComponent } from "react";
import { XYPosition } from "@xyflow/system";
import { AutoLayoutDirection, BBox, DeploymentFqn, DiagramEdge, DiagramNode, DiagramNodeDriftReason, DynamicViewFlow, ExclusiveUnion, Fqn, IconUrl, MarkdownOrString, NonEmptyReadonlyArray, StepPath, ViewId } from "@likec4/core/types";
import { Simplify } from "type-fest";
//#region src/likec4diagram/types.d.ts
export declare namespace Types {
  type LeafNodeData = Simplify<BaseNodeData & NonOptional<Pick<DiagramNode, 'id' | 'title' | 'technology' | 'description' | 'notes' | 'color' | 'shape' | 'width' | 'level' | 'height' | 'style' | 'tags' | 'x' | 'y'>> & {
    /**
     * View layout direction, used by DefaultHandles to position node handles
     */
    viewLayoutDir?: AutoLayoutDirection | undefined;
    /**
     * View this node belongs to
     */
    viewId: ViewId;
    isMultiple?: boolean | undefined;
    icon: string | null;
    drifts: NonEmptyReadonlyArray<DiagramNodeDriftReason> | null;
  }>;
  /**
   * Represents element from logical model
   */
  type ElementNodeData = Simplify<LeafNodeData & {
    modelFqn: Fqn;
    deploymentFqn?: never;
    /**
     * If set - this node has navigation to another view and diagram has handler for this
     */
    navigateTo: ViewId | null;
  }>;
  /**
   * Represents element from deployment model
   */
  type DeploymentElementNodeData = Simplify<LeafNodeData & {
    navigateTo: ViewId | null;
    deploymentFqn: DeploymentFqn;
    modelFqn: Fqn | null;
  }>;
  type SequenceActorNodePort = {
    id: string;
    cx: number;
    cy: number;
    height: number;
    type: 'target' | 'source';
    position: 'left' | 'right' | 'top' | 'bottom';
    hidden?: boolean;
  };
  type SequenceActorNodeData = Simplify<LeafNodeData & {
    navigateTo: ViewId | null;
    modelFqn: Fqn | null;
    ports: Array<SequenceActorNodePort>;
    viewHeight: number;
  }>;
  /**
   * Represents subflow area in the diagram
   * `try` and `alt` flows have special handling in the diagram
   */
  type SequenceSubflowData = LeafNodeData & {
    flowId: StepPath;
    title: string | undefined;
    /**
     * This is first subflow in current flow
     */
    isFirst?: boolean | undefined;
    /**
     * This is last subflow in current flow
     */
    isLast?: boolean | undefined;
    collapsed: boolean;
  } & ({
    flowType: Exclude<DynamicViewFlow.SubFlowType, 'try' | 'alt'>;
  } | SequenceSubflowData.AltOrTry);
  namespace SequenceSubflowData {
    type AltOrTry = {
      flowType: 'try' | 'alt';
      headerHeight: number;
    };
  }
  /**
   * @deprecated Use {@link SequenceSubflowData} instead
   */
  type SequenceParallelAreaData = Simplify<LeafNodeData & {
    parallelPrefix: string;
  }>;
  type CompoundNodeData = Simplify<BaseNodeData & NonOptional<Pick<DiagramNode, 'id' | 'title' | 'notes' | 'color' | 'shape' | 'style' | 'tags' | 'x' | 'y'>> & {
    /**
     * View layout direction, used by DefaultHandles to position node handles
     */
    viewLayoutDir?: AutoLayoutDirection | undefined;
    /**
     * View this node belongs to
     */
    viewId: ViewId;
    depth: number;
    icon?: IconUrl;
    drifts: NonEmptyReadonlyArray<DiagramNodeDriftReason> | null;
  }>;
  type CompoundElementNodeData = Simplify<CompoundNodeData & {
    modelFqn: Fqn;
    deploymentFqn?: never;
    /**
     * If set - this node has navigation to another view and diagram has handler for this
     */
    navigateTo: ViewId | null;
  }>;
  type CompoundDeploymentNodeData = Simplify<CompoundNodeData & {
    deploymentFqn: DeploymentFqn;
    /**
     * If set - this node refers to a model element
     */
    modelFqn: Fqn | null;
    /**
     * If set - this node has navigation to another view and diagram has handler for this
     */
    navigateTo: ViewId | null;
  }>;
  type ViewGroupNodeData = Simplify<CompoundNodeData & {
    isViewGroup: true;
  }>;
  /**
   * Represents a leaf element rendered as a compact circle in "graph" display variant.
   * Shares {@link LeafNodeData}'s geometry fields (x/y/width/height/style) with the other
   * leaf node types, even though "graph" mode renders a fixed-size circle instead - this
   * keeps generic node utilities (bounds, drifts, notes, etc.) working across all node types.
   */
  type GraphElementNodeData = Simplify<LeafNodeData & {
    modelFqn: Fqn | null;
    deploymentFqn: DeploymentFqn | null;
    navigateTo: ViewId | null;
  }>;
  type ElementNode = BaseNode<ElementNodeData, 'element'>;
  type DeploymentElementNode = BaseNode<DeploymentElementNodeData, 'deployment'>;
  type GraphElementNode = BaseNode<GraphElementNodeData, 'graph-element'>;
  type SequenceActorNode = BaseNode<SequenceActorNodeData, 'seq-actor'>;
  type SequenceParallelArea = BaseNode<SequenceParallelAreaData, 'seq-parallel'>;
  type SequenceSubflowArea = BaseNode<SequenceSubflowData, 'seq-subflow'>;
  type CompoundElementNode = BaseNode<CompoundElementNodeData, 'compound-element'>;
  type CompoundDeploymentNode = BaseNode<CompoundDeploymentNodeData, 'compound-deployment'>;
  type ViewGroupNode = BaseNode<ViewGroupNodeData, 'view-group'>;
  type AnyNode = ElementNode | DeploymentElementNode | CompoundElementNode | CompoundDeploymentNode | ViewGroupNode | SequenceActorNode | SequenceParallelArea | SequenceSubflowArea | GraphElementNode;
  type NodeType = AnyNode['type'];
  type NodeData = ExclusiveUnion<{
    ElementNodeData: ElementNodeData;
    DeploymentElementNodeData: DeploymentElementNodeData;
    CompoundElementNodeData: CompoundElementNodeData;
    CompoundDeploymentNodeData: CompoundDeploymentNodeData;
    ViewGroupNodeData: ViewGroupNodeData;
    SequenceActorNodeData: SequenceActorNodeData;
    SequenceParallelAreaData: SequenceParallelAreaData;
    SequenceSubflowAreaData: SequenceSubflowData;
    GraphElementNodeData: GraphElementNodeData;
  }>;
  type Node<Type extends NodeType = NodeType> = Extract<AnyNode, {
    type: Type;
  }>;
  type NodeProps<Type extends NodeType = NodeType> = BaseNodeProps<Node<Type>>;
  type RelationshipEdgeData = Simplify<BaseEdgeData & NonOptional<Pick<DiagramEdge, 'id' | 'label' | 'labelBBox' | 'technology' | 'points' | 'dir' | 'color' | 'line' | 'head' | 'tail' | 'navigateTo' | 'astPath' | 'drifts'>> & {
    notes: MarkdownOrString | null;
    labelXY: XYPosition | null;
    isLabelCustomized?: boolean | undefined;
    controlPoints: XYPosition[] | undefined | null;
    /**
     * When dynamic view in "diagram" variant
     * Edges are RelationshipEdgeData - stepnum is used to determine the step number
     * (backward compatibility)
     */
    stepnum?: number;
  }>;
  type SequenceStepEdgeData = Simplify<BaseEdgeData & NonOptional<Pick<DiagramEdge, 'label' | 'technology' | 'points' | 'dir' | 'color' | 'line' | 'head' | 'tail' | 'navigateTo' | 'astPath' | 'drifts'>> & {
    id: StepPath;
    state?: 'processed' | 'active' | 'skipped' | 'pending' | null;
    stepnum: number;
    parentFlow: null | {
      id: StepPath;
      type: DynamicViewFlow.SubFlowType;
    };
    notes: MarkdownOrString | null;
    labelXY: XYPosition | null;
    labelBBox: BBox;
    isLabelCustomized?: boolean | undefined;
    controlPoints: XYPosition[] | undefined | null;
  }>;
  type RelationshipEdge = BaseEdge<RelationshipEdgeData, 'relationship'>;
  type SequenceStepEdge = BaseEdge<SequenceStepEdgeData, 'seq-step'>;
  type AnyEdge = RelationshipEdge | SequenceStepEdge;
  type EdgeType = AnyEdge['type'];
  type Edge<Type extends EdgeType = EdgeType> = Extract<AnyEdge, {
    type: Type;
  }>;
  type EdgeProps<Type extends EdgeType = EdgeType> = BaseEdgeProps<Edge<Type>>;
  type EdgeData = ExclusiveUnion<{
    RelationshipEdgeData: RelationshipEdgeData;
    SequenceStepEdgeData: SequenceStepEdgeData;
  }>;
  type NodeRenderer<T extends NodeType> = FunctionComponent<NodeProps<T>>;
  type NodeRenderers = { [T in NodeType]: NodeRenderer<T>; };
  type EdgeRenderer<T extends EdgeType> = FunctionComponent<EdgeProps<T>>;
  type EdgeRenderers = { [T in EdgeType]: EdgeRenderer<T>; };
}
//#endregion