// JS: IVisibilityTestable.$class
val clazz = IVisibilityTestable.yclass

Boolean.yclass   // YBoolean.$class
Double.yclass    // YNumber.$class
Int.yclass       // YNumber.$class
String.yclass    // YString.$class

fun(o: Any?) {
    val isNode: Boolean = o yIs INode

    val optNode: INode? = o yOpt INode

    val node: INode = o yAs INode
}

val graph: IGraph = DefaultGraph()
val node = graph.createNode()

// for classes
val t13: TimeSpan = node.lookup()      // reified lookup type
val t14 = node.lookup<TimeSpan>()       // 'TimeSpan?'

val t23: TimeSpan = node.lookupValue()  // reified lookup type
val t24 = node.lookupValue<TimeSpan>()  // 'TimeSpan'

// for interfaces
val h13: IHitTestable = node.lookup()      // reified lookup type
val h14 = node.lookup<IHitTestable>()       // 'IHitTestable?'

val h23: IHitTestable = node.lookupValue()  // reified lookup type
val h24 = node.lookupValue<IHitTestable>()  // 'IHitTestable'

val clazz: YClass<IVisibilityTestable> = IVisibilityTestable.yclass

// strict lookup
val visibilityTestable: IVisibilityTestable = renderer.lookup(IVisibilityTestable.yclass)
val boundsProvider: IBoundsProvider = renderer.lookup(IBoundsProvider.yclass)

val layout = HierarchicLayout().apply {
    layoutOrientation = LEFT_TO_RIGHT
    automaticEdgeGrouping = true
    gridSpacing = 20.0
}

val layout = HierarchicLayout {
    layoutOrientation = LEFT_TO_RIGHT
    automaticEdgeGrouping = true
    gridSpacing = 20.0
}

val mode = CreateEdgeInputMode {
    beginHitTestable = IHitTestable { _, location -> location.x > 0.0 }
    endHitTestable = IHitTestable { _, location -> location.x < 0.0 }
}

import yfiles.graph.GraphItemTypes.*
import yfiles.input.GraphViewerInputMode
import yfiles.lang.contains
import yfiles.lang.or

val inputMode = GraphViewerInputMode {
    clickableItems = NODE or EDGE or LABEL
}

val nodesAreClickable = NODE in inputMode.clickableItems // true

import yfiles.algorithms.GraphChecker.isAcyclic
import yfiles.algorithms.GraphChecker.isCyclic
import yfiles.algorithms.Trees.isForest

// ...

val graph: Graph = DefaultLayoutGraph()
// JS: GraphChecker.isCyclic(graph)
graph.isCyclic()
// JS: GraphChecker.isAcyclic(graph)
graph.isAcyclic()
// JS: Trees.isForest(graph)
graph.isForest()

import yfiles.collections.asSequence
import yfiles.collections.iterator

val graph: IGraph = DefaultGraph()
// ...

// iterator() extension allows for loops for IEnumerable
for (node in graph.nodes) {
    println("Node layout: ${node.layout}")
}

// asSequence() extension
graph.nodes
    .asSequence()
    .forEach { println("Node layout: ${node.layout}") }

import yfiles.algorithms.asSequence
import yfiles.algorithms.iterator

val graph: Graph = DefaultLayoutGraph()
// ...

// iterator() extension allows for loops for ICursor
for (node in graph.getNodeCursor()) {
    println("Node index: ${node.index}")
}

// asSequence() extension
graph.getNodeCursor()
    .asSequence()
    .forEach { println("Node index: ${node.index}") }

import yfiles.graph.observable

class User : Tag {
    var name: String by observable("Frodo")
    var age: Int by observable(50)
}

val c: TimeSpan = 2.hours
val o: TimeSpan = 0.minutes
val d: TimeSpan = 1.seconds
val e: TimeSpan = 3.milliseconds

import yfiles.lang.ResourceKeys.COPY
import yfiles.lang.ResourceKeys.COPY_KEY
import yfiles.lang.Resources.invariant
import yfiles.lang.get

fun main() {
    println(invariant[COPY]) // Copy
    println(invariant[COPY_KEY]) // Action+C;Ctrl+Ins
}