proc initLayoutManager(): LayoutManager {...}{.raises: [], tags: [].}

proc measure(self: LayoutManager; elem: Element; availableSize: Vec2[float]): void {...}{.
    raises: [Exception, UnpackError], tags: [RootEffect].}

proc arrange(self: LayoutManager; elem: Element; rect: Bounds): void {...}{.
    raises: [Exception, UnpackError], tags: [RootEffect].}

proc onlayoutPerformed(handler`gensym14260643: (Bounds) -> void): void {...}{.raises: [],
    tags: [].}

proc emitlayoutPerformed(args`gensym14260644: Bounds): void {...}{.raises: [], tags: [].}

proc observelayoutPerformed(): Observable[Bounds] {...}{.raises: [Exception],
    tags: [RootEffect].}

proc performOutstandingLayoutsAndMeasures(rect: Bounds): void {...}{.
    raises: [KeyError, Exception, UnpackError], tags: [RootEffect].}

proc invalidateLayout(self: Element): void {...}{.raises: [], tags: [].}

proc size(props: ElemProps): Option[Vec2[float]] {...}{.raises: [UnpackError], tags: [].}

proc size=(props: ElemProps; value: Vec2[float]): void {...}{.raises: [], tags: [].}

proc pos(props: ElemProps): Option[Vec2[float]] {...}{.raises: [UnpackError], tags: [].}

proc pos=(props: ElemProps; value: Vec2[float]): void {...}{.raises: [], tags: [].}

proc isRoot(self: Element): bool {...}{.raises: [], tags: [].}

proc getRoot(self: Element): Element {...}{.raises: [UnpackError], tags: [].}

proc isRooted(self: Element): bool {...}{.raises: [UnpackError], tags: [].}

proc dispatchOnRooted(self: Element): void {...}{.raises: [Exception, UnpackError],
    tags: [RootEffect].}

proc dispatchOnUnrooted(self: Element): void {...}{.raises: [Exception, UnpackError],
    tags: [RootEffect].}

proc addChild(self: Element; child: Element): void {...}{.raises: [UnpackError, Exception],
    tags: [RootEffect].}

proc removeChild(self: Element; child: Element): void {...}{.
    raises: [Exception, UnpackError], tags: [RootEffect].}

proc setChildren(self: Element; value: seq[Element]): void {...}{.
    raises: [Exception, UnpackError], tags: [RootEffect].}

proc newElement(props: ElemProps = ElemProps(); children: seq[Element] = @[];
               layout: Option[Layout] = none(); drawable: Option[Drawable] = none();
               onRooted: Option[proc (i0: Element): void] = none();
               onUnrooted: Option[proc (i0: Element): void] = none()): Element {...}{.
    raises: [], tags: [TimeEffect].}

proc createPanel(children: varargs[Element]): Element {...}{.raises: [], tags: [TimeEffect].}

proc createPanel(props: ElemProps; children: varargs[Element]): Element {...}{.raises: [],
    tags: [TimeEffect].}

proc createPanel(props: ElemProps; children: seq[Element]): Element {...}{.raises: [],
    tags: [TimeEffect].}

proc createPanel(margin: Thickness[float]; children: varargs[Element]): Element {...}{.
    raises: [], tags: [TimeEffect].}

proc applyLayoutConstraints(element: Element; constraints: Vec2[float]): Vec2[float] {...}{.
    raises: [UnpackError], tags: [].}

proc log(self: Element; msg: string): void {...}{.raises: [UnpackError], tags: [].}

proc printTree(self: Element; prefix: string = ""): void {...}{.
    raises: [UnpackError, ValueError], tags: [].}

proc `$`(p: ElemProps): string {...}{.raises: [ValueError], tags: [].}

proc `$`(p: Element): string {...}{.raises: [ValueError], tags: [].}

proc margin(p: Element): Thickness[float] {...}{.raises: [], tags: [].}

proc arrangeOverride(self: Element; finalSize: Vec2[float]): Vec2[float] {...}{.
    raises: [Exception, UnpackError], tags: [RootEffect].}

proc arrange(self: Element; rect: Rect): void

proc measure(self: Element; availableSize: Vec2[float]): void {...}{.
    raises: [UnpackError, Exception, UnpackError, Exception], tags: [RootEffect].}

proc measureOverride(self: Element; availableSize: Vec2[float]): Vec2[float] {...}{.
    raises: [Exception, UnpackError], tags: [RootEffect].}

proc actualWorldPosition(self: Element): Vec2[float] {...}{.raises: [UnpackError], tags: [].}

proc boundsInWorldSpace(self: Element): Option[Bounds] {...}{.raises: [UnpackError],
    tags: [].}

proc isPointInside(self: Element; point: Vec2[float]): bool {...}{.raises: [UnpackError],
    tags: [].}

proc relativeTo(self: Vec2[float]; elem: Element): Vec2[float] {...}{.
    raises: [UnpackError], tags: [].}

proc relativeTo(self: Rect[float]; elem: Element): Rect[float] {...}{.
    raises: [UnpackError], tags: [].}