export declare const get: Effect.Effect<Option.Option<Canvas>, never, Plugin.Plugin>

export declare const prop: <K extends keyof Canvas>(key: K) => Effect.Effect<Canvas[K], never, Canvas>

export declare const addCommand: <R, E>(
  command: Plugin.Command<R, E>
) => Effect.Effect<void, never, Plugin.Plugin | Scope.Scope | Exclude<R, Canvas>>

export interface BBox {
  maxX: number
  maxY: number
  minX: number
  minY: number
}

export interface Canvas {
  readonly _: unique symbol

  readonly getData: () => CanvasData
  readonly createTextNode: (args: {
    pos: Obsidian.Point
    text?: string
    size?: Size
    focus?: boolean
  }) => CanvasTextNode

  readonly: boolean
  view: Obsidian.MarkdownView
  x: number
  y: number
  nodes: Map<string, CanvasNode>
  edges: Map<string, CanvasEdge>
  nodeInteractionLayer: CanvasInteractionLayer
  selection: Set<CanvasNode>
  menu: CanvasMenu
  wrapperEl: HTMLElement
  history: any
  requestPushHistory: any
  nodeIndex: any

  deselectAll(): void
  getContainingNodes(coords: BBox): Array<CanvasNode>
  getEdgesForNode(node: CanvasNode): Array<CanvasEdge>
  getViewportNodes(): Array<CanvasNode>
  importData(data: CanvasData): void
  panTo(x: number, y: number): void
  panIntoView(bbox: BBox): void
  requestFrame(): void
  requestSave(save?: boolean, triggerBySelf?: boolean): void
  select(nodes: CanvasNode): void
  selectOnly(nodes: CanvasNode): void
  showQuickSettingsMenu(menu: Obsidian.Menu): void
  zoomToSelection(): void
}

export interface CanvasEdge {
  id: string

  label: string | undefined
  lineStartGroupEl: SVGGElement
  lineEndGroupEl: SVGGElement
  lineGroupEl: SVGGElement

  path: {
    display: SVGPathElement
    interaction: SVGPathElement
  }

  from: {
    side: "left" | "right" | "top" | "bottom"
    node: CanvasNode
  }

  to: {
    side: "left" | "right" | "top" | "bottom"
    node: CanvasNode
  }

  canvas: Canvas
  bbox: BBox

  unknownData: CanvasNodeUnknownData
}

export interface CanvasFileNode extends CanvasNode {
  file: Obsidian.TFile
}

export interface CanvasGroupNode extends CanvasNode {
  label: string
}

export interface CanvasInteractionLayer {
  interactionEl: HTMLElement
  canvas: Canvas
  target: CanvasNode | null

  render(): void

  setTarget(target: CanvasNode | null): void
}

export interface CanvasLinkNode extends CanvasNode {
  url: string
}

export interface CanvasMenu {
  containerEl: HTMLElement
  menuEl: HTMLElement
  canvas: Canvas
  selection: CanvasSelection

  render(): void

  updateZIndex(): void
}

export interface CanvasNode {
  id: string

  x: number
  y: number
  width: number
  height: number
  zIndex: number
  bbox: BBox
  unknownData: CanvasNodeUnknownData
  renderedZIndex: number
  color: string

  headerComponent: Obsidian.Component

  nodeEl: HTMLElement
  labelEl: HTMLElement
  contentEl: HTMLElement
  containerEl: HTMLElement

  canvas: Canvas
  app: Obsidian.App

  getBBox(containing?: boolean): BBox
  getData: () => AllCanvasNodeData
  moveTo({ x, y }: { x: number; y: number }): void
  setColor: (color: string) => void
  render(): void

  readonly [key: string]: any
}

export interface CanvasNodeUnknownData {
  id: string
  collapsed: boolean
  [key: string]: any
}

export interface CanvasSelection {
  selectionEl: HTMLElement
  resizerEls: HTMLElement
  canvas: Canvas
  bbox: BBox | undefined

  render(): void

  hide(): void

  onResizePointerDown(e: PointerEvent, direction: CanvasDirection): void

  update(bbox: BBox): void
}

export interface CanvasTextNode extends CanvasNode {
  text: string
  child: any
}

export interface Size {
  readonly height: number
  readonly width: number
}

export declare const createEdge: (options: {
  readonly from: CanvasNode
  readonly fromSide?: NodeSide
  readonly to: CanvasNode
  readonly toSide?: NodeSide
}) => Effect.Effect<void, never, Canvas>

export declare const nodeChanges: (canvas: Canvas) => Stream.Stream<number>

export declare const onActive: <R, E>(
  effect: Effect.Effect<void, E, R>
) => Effect.Effect<void, never, Plugin.Plugin | Scope.Scope | Exclude<Exclude<R, Scope.Scope>, Canvas>>

export declare const onNodeChanges: <R, E>(
  effect: Effect.Effect<void, E, R>
) => Effect.Effect<void, never, Plugin.Plugin | Scope.Scope | Exclude<R, Canvas>>

export declare const selectedNode: Effect.Effect<Option.Option<CanvasNode>, never, Canvas>

export declare const Canvas: Context.Tag<Canvas, Canvas>