getData(): Required<GraphData>;

const graphData = graph.getData();
console.log('Node data:', graphData.nodes);
console.log('Edge data:', graphData.edges);
console.log('Combo data:', graphData.combos);

// Get all node data
getNodeData(): NodeData[];

// Get single node data
getNodeData(id: ID): NodeData;

// Get multiple node data
getNodeData(ids: ID[]): NodeData[];

// Get all nodes
const nodes = graph.getNodeData();

// Get single node
const node = graph.getNodeData('node1');
console.log('Node position:', node.style.x, node.style.y);

// Get multiple nodes
const [node1, node2] = graph.getNodeData(['node1', 'node2']);

// Get all edge data
getEdgeData(): EdgeData[];

// Get single edge data
getEdgeData(id: ID): EdgeData;

// Get multiple edge data
getEdgeData(ids: ID[]): EdgeData[];

// Get all edges
const edges = graph.getEdgeData();

// Get single edge
const edge = graph.getEdgeData('edge1');
console.log('Edge source and target:', edge.source, edge.target);

// Get multiple edges
const [edge1, edge2] = graph.getEdgeData(['edge1', 'edge2']);

// Get all combo data
getComboData(): ComboData[];

// Get single combo data
getComboData(id: ID): ComboData;

// Get multiple combo data
getComboData(ids: ID[]): ComboData[];

// Get all combos
const combos = graph.getComboData();

// Get single combo
const combo = graph.getComboData('combo1');
console.log('Nodes in combo:', combo.children);

// Get multiple combos
const [combo1, combo2] = graph.getComboData(['combo1', 'combo2']);

// Get single element data
getElementData(id: ID): ElementDatum;

// Get multiple element data
getElementData(ids: ID[]): ElementDatum[];

const element = graph.getElementData('node-1');
console.log('Element data:', element);

const elements = graph.getElementData(['node-1', 'edge-1']);
console.log('Multiple element data:', elements);

// Get node data in a specified state
getElementDataByState(elementType: 'node', state: string): NodeData[];

// Get edge data in a specified state
getElementDataByState(elementType: 'edge', state: string): EdgeData[];

// Get combo data in a specified state
getElementDataByState(elementType: 'combo', state: string): ComboData[];

const selectedNodes = graph.getElementDataByState('node', 'selected');
console.log('Selected nodes:', selectedNodes);

const selectedEdges = graph.getElementDataByState('edge', 'selected');
console.log('Selected edges:', selectedEdges);

const selectedCombos = graph.getElementDataByState('combo', 'selected');
console.log('Selected combos:', selectedCombos);

getNeighborNodesData(id: ID): NodeData[];

const neighbors = graph.getNeighborNodesData('node-1');
console.log('Neighbor nodes:', neighbors);

getRelatedEdgesData(id: ID, direction?: EdgeDirection): EdgeData[];

const relatedEdges = graph.getRelatedEdgesData('node-1');
console.log('Related edges:', relatedEdges);

getParentData(id: ID, hierarchy: HierarchyKey): NodeLikeData | undefined;

// Get the parent node in a tree graph
const treeParent = graph.getParentData('node1', 'tree');

// Get the parent combo in a combo
const comboParent = graph.getParentData('node1', 'combo');

getChildrenData(id: ID): (NodeData \| ComboData)[];

// Get the child elements of a combo
const children = graph.getChildrenData('combo1');
console.log('Number of child nodes:', children.length);

// Process each child element
children.forEach((child) => {
  console.log('Child element ID:', child.id);
});

getAncestorsData(id: ID, hierarchy: HierarchyKey): NodeLikeData[];

// Get all ancestor nodes in a tree graph
const treeAncestors = graph.getAncestorsData('node1', 'tree');
console.log(
  'Ancestor node path:',
  treeAncestors.map((node) => node.id),
);

// Get all parent combos in a combo
const comboAncestors = graph.getAncestorsData('node1', 'combo');

getDescendantsData(id: ID): NodeLikeData[];

// Get all descendants of a node
const descendants = graph.getDescendantsData('node1');
console.log('Number of descendants:', descendants.length);

// Process all descendant elements
descendants.forEach((descendant) => {
  console.log('Descendant element ID:', descendant.id);
});

setData(data: GraphData | ((prev: GraphData) => GraphData)): void;

// Directly set data
graph.setData({
  nodes: [
    { id: 'node1', style: { x: 100, y: 100 } },
    { id: 'node2', style: { x: 200, y: 200 } },
  ],
  edges: [{ id: 'edge1', source: 'node1', target: 'node2' }],
});

// Use functional incremental update: get current graph data and return new graph data
graph.setData((prev) => ({
  ...prev,
  nodes: [...prev.nodes, { id: 'node3', style: { x: 300, y: 300 } }],
}));

addData(data: GraphData | ((prev: GraphData) => GraphData)): void;

graph.addData({
  nodes: [{ id: 'node-1' }, { id: 'node-2' }],
  edges: [{ source: 'node-1', target: 'node-2' }],
});

addNodeData(data: NodeData[] | ((prev: NodeData[]) => NodeData[])): void;

// Add single node
graph.addNodeData([
  {
    id: 'node1',
    style: { x: 100, y: 100 },
    data: { label: 'Node 1' },
  },
]);

// Add multiple nodes
graph.addNodeData([
  { id: 'node2', style: { x: 200, y: 200 } },
  { id: 'node3', style: { x: 300, y: 300 } },
]);

// Functional addition
graph.addNodeData((prev) => [...prev, { id: 'node4', style: { x: 400, y: 400 } }]);

addEdgeData(data: EdgeData[] | ((prev: EdgeData[]) => EdgeData[])): void;

// Add single edge
graph.addEdgeData([
  {
    id: 'edge1',
    source: 'node1',
    target: 'node2',
    data: {
      weight: 1,
      label: 'Relation',
    },
  },
]);

// Add multiple edges
graph.addEdgeData([
  { id: 'edge2', source: 'node2', target: 'node3' },
  { id: 'edge3', source: 'node3', target: 'node1' },
]);

// Functional addition
graph.addEdgeData((prev) => [...prev, { id: 'edge4', source: 'node1', target: 'node4' }]);

addComboData(data: ComboData[] | ((prev: ComboData[]) => ComboData[])): void;

graph.addComboData([{ id: 'combo1', children: ['node1', 'node2'] }]);

addChildrenData(parentId: ID, childrenData: NodeData[]): void;

graph.addChildrenData('node1', [{ id: 'node2' }]);

removeData(ids: DataID | ((data: GraphData) => DataID)): void;

graph.removeData({
  nodes: ['node-1', 'node-2'],
  edges: ['edge-1'],
});

removeNodeData(ids: ID[] | ((data: NodeData[]) => ID[])): void;

graph.removeNodeData(['node-1', 'node-2']);

removeEdgeData(ids: ID[] | ((data: EdgeData[]) => ID[])): void;

graph.removeEdgeData(['edge-1']);

removeComboData(ids: ID[] | ((data: ComboData[]) => ID[])): void;

graph.removeComboData(['combo-1']);

updateData(data: PartialGraphData | ((prev: GraphData) => PartialGraphData)): void;

graph.updateData({
  nodes: [{ id: 'node-1', style: { x: 100, y: 100 } }],
  edges: [{ id: 'edge-1', style: { lineWidth: 2 } }],
});

updateNodeData(data: NodeData[] | ((prev: NodeData[]) => NodeData[])): void;

graph.updateNodeData([{ id: 'node-1', style: { x: 100, y: 100 } }]);

updateEdgeData(data: (PartialEdgeData<EdgeData>[] | ((prev: EdgeData[]) => PartialEdgeData<EdgeData>[]))): void;

graph.updateEdgeData([{ id: 'edge-1', style: { lineWidth: 2 } }]);

updateComboData(data: (ComboData[] | ((prev: ComboData[]) => ComboData[]))): void;

graph.updateComboData([{ id: 'combo-1', style: { x: 100, y: 100 } }]);

type ID = string;

interface DataID {
  nodes?: ID[];
  edges?: ID[];
  combos?: ID[];
}

interface GraphData {
  nodes?: NodeData[];
  edges?: EdgeData[];
  combos?: ComboData[];
}

interface NodeData {
  id: string; // Node ID
  type?: string; // Node type
  data?: Record<string, any>; // Node data
  style?: Record<string, any>; // Node style
  states?: string[]; // Initial node states
  combo?: string; // Belonging combo
  children?: string[]; // Array of child node IDs
}

interface EdgeData {
  source: string; // Source ID
  target: string; // Target ID
  id?: string; // Edge ID
  type?: string; // Edge type
  data?: Record<string, any>; // Edge data
  style?: Record<string, any>; // Edge style
  states?: string[]; // Initial edge states
}

interface ComboData {
  id: string; // Combo ID
  type?: string; // Combo type
  data?: Record<string, any>; // Combo data
  style?: Record<string, any>; // Combo style
  states?: string[]; // Initial combo states
  combo?: string; // Parent combo ID
}