taffy-js 0.2.5 → 0.2.6

package/pkg/taffy_wasm.d.ts

@@ -0,0 +1,2074 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Available space constraint for layout computation.
+ *
+ * Specifies how much space is available for a node during layout calculation.
+ * This is passed to `computeLayout()` to define the container constraints.
+ *
+ * @remarks
+ * - Use `number` when you have a fixed container size
+ * - Use `"minContent"` to shrink-wrap to the minimum content size
+ * - Use `"maxContent"` to expand to fit all content without wrapping
+ *
+ * @example
+ * ```typescript
+ * import init, { TaffyTree, Style, type AvailableSpace, type Size } from 'taffy-js';
+ *
+ * await init();
+ * const tree = new TaffyTree();
+ * const root: bigint = tree.newLeaf(new Style());
+ *
+ * // Fixed size container with type annotation
+ * const fixedSpace: Size<AvailableSpace> = {
+ *   width: 800,
+ *   height: 600
+ * };
+ * tree.computeLayout(root, fixedSpace);
+ *
+ * // Flexible width, fixed height
+ * const flexibleSpace: Size<AvailableSpace> = {
+ *   width: "maxContent",
+ *   height: 400
+ * };
+ * tree.computeLayout(root, flexibleSpace);
+ * ```
+ */
+export type AvailableSpace = number | "minContent" | "maxContent";
+
+/**
+ * Generic size type with width and height.
+ *
+ * A two-dimensional container for width and height values. The type parameter `T`
+ * determines what kind of values are stored.
+ *
+ * @typeParam T - The type of each dimension (e.g., `number`, `Dimension`, `AvailableSpace`)
+ *
+ * @property width - The horizontal dimension value
+ * @property height - The vertical dimension value
+ *
+ * @example
+ * ```typescript
+ * import type { Size, Dimension, AvailableSpace } from 'taffy-js';
+ *
+ * // Size with explicit type parameters
+ * const pixelSize: Size<number> = { width: 200, height: 100 };
+ *
+ * const dimensionSize: Size<Dimension> = {
+ *   width: { Length: 200 },
+ *   height: { Percent: 50 }
+ * };
+ *
+ * const availableSize: Size<AvailableSpace> = {
+ *   width: 800,
+ *   height: "MaxContent"
+ * };
+ * ```
+ */
+export interface Size<T> {
+  /** The horizontal dimension value */
+  width: T;
+  /** The vertical dimension value */
+  height: T;
+}
+
+/**
+ * Custom measure function for leaf nodes with text or other dynamic content.
+ *
+ * This callback is invoked during layout computation for leaf nodes that need
+ * custom sizing based on their content (e.g., text nodes that need text measurement).
+ *
+ * @param knownDimensions - Dimensions already determined by constraints. Each dimension
+ *                          is `number` if known, or `null` if needs to be measured.
+ * @param availableSpace - The available space constraints for the node. Can be definite
+ *                         pixels, "minContent", or "maxContent".
+ * @param node - The node ID (`bigint`) of the node being measured
+ * @param context - User-provided context attached to the node via `newLeafWithContext()`
+ * @param style - The node's current Style configuration
+ *
+ * @returns - The measured size of the content in pixels
+ *
+ * @example
+ * ```typescript
+ * import init, { TaffyTree, Style, type MeasureFunction, type Size } from 'taffy-js';
+ *
+ * interface TextContext {
+ *   text: string;
+ *   fontSize: number;
+ * }
+ *
+ * await init();
+ * const tree = new TaffyTree();
+ *
+ * const style = new Style();
+ * const context: TextContext = { text: "Hello, World!", fontSize: 16 };
+ * const textNode: bigint = tree.newLeafWithContext(style, context);
+ *
+ * // Typed measure function
+ * const measureText: MeasureFunction = (
+ *   knownDimensions,
+ *   availableSpace,
+ *   node,
+ *   context,
+ *   style
+ * ): Size<number> => {
+ *   const ctx = context as TextContext | undefined;
+ *   if (!ctx?.text) return { width: 0, height: 0 };
+ *
+ *   const width = knownDimensions.width ?? measureTextWidth(ctx.text, ctx.fontSize);
+ *   const height = knownDimensions.height ?? ctx.fontSize * 1.2;
+ *
+ *   return { width, height };
+ * };
+ *
+ * tree.computeLayoutWithMeasure(
+ *   textNode,
+ *   { width: 200, height: "maxContent" },
+ *   measureText
+ * );
+ * ```
+ */
+export type MeasureFunction = (
+  knownDimensions: Size<number | null>,
+  availableSpace: Size<AvailableSpace>,
+  node: bigint,
+  context: any,
+  style: Style,
+) => Size<number>;
+
+/**
+ * Dimension type supporting length, percentage, or auto values.
+ *
+ * Used for sizing properties like `width`, `height`, `flexBasis`, etc.
+ *
+ * @remarks
+ * - `number`: Fixed size in pixels
+ * - `"{number}%"`: Percentage of parent's size (0-100)
+ * - `"auto"`: Size determined by content or layout algorithm
+ *
+ * @example
+ * ```typescript
+ * import { Style, type Dimension, type Size } from 'taffy-js';
+ *
+ * const style = new Style();
+ *
+ * // With explicit type annotations
+ * const fixedSize: Size<Dimension> = {
+ *   width: 200,
+ *   height: 100
+ * };
+ *
+ * const percentSize: Size<Dimension> = {
+ *   width: "50%",
+ *   height: "100%"
+ * };
+ *
+ * const autoSize: Size<Dimension> = {
+ *   width: "auto",
+ *   height: "auto"
+ * };
+ *
+ * style.size = fixedSize;
+ * ```
+ */
+export type Dimension = number | `${number}%` | "auto";
+
+/**
+ * Length or percentage value (no auto support).
+ *
+ * Used for properties that require explicit values, such as `padding`, `border`, and `gap`.
+ *
+ * @remarks
+ * - `number`: Fixed size in pixels
+ * - `"{number}%"`: Percentage of parent's size (0-100)
+ *
+ * @example
+ * ```typescript
+ * import { Style, type LengthPercentage, type Rect, type Size } from 'taffy-js';
+ *
+ * const style = new Style();
+ *
+ * const padding: Rect<LengthPercentage> = {
+ *   left: 10,
+ *   right: 10,
+ *   top: 5,
+ *   bottom: 5
+ * };
+ *
+ * const gap: Size<LengthPercentage> = {
+ *   width: "5%",
+ *   height: "5%"
+ * };
+ *
+ * style.padding = padding;
+ * style.gap = gap;
+ * ```
+ */
+export type LengthPercentage = number | `${number}%`;
+
+/**
+ * Length, percentage, or auto value.
+ *
+ * Used for properties that support auto values, such as `margin` and `inset`.
+ *
+ * @remarks
+ * - `number`: Fixed size in pixels
+ * - `"{number}%"`: Percentage of parent's size (0-100)
+ * - `"auto"`: Automatic value (behavior depends on property)
+ *
+ * @example
+ * ```typescript
+ * import { Style, type LengthPercentageAuto, type Rect } from 'taffy-js';
+ *
+ * const style = new Style();
+ *
+ * // Auto margins for horizontal centering
+ * const centerMargin: Rect<LengthPercentageAuto> = {
+ *   left: "auto",
+ *   right: "auto",
+ *   top: 0,
+ *   bottom: 0
+ * };
+ *
+ * style.margin = centerMargin;
+ * ```
+ */
+export type LengthPercentageAuto = number | `${number}%` | "auto";
+
+/**
+ * Point with x and y coordinates/values.
+ *
+ * Used for properties that have separate horizontal (x) and vertical (y) values,
+ * such as `overflow`.
+ *
+ * @typeParam T - The type of each coordinate
+ *
+ * @property x - The horizontal value
+ * @property y - The vertical value
+ *
+ * @example
+ * ```typescript
+ * import { Style, Overflow, type Point } from 'taffy-js';
+ *
+ * const style = new Style();
+ *
+ * const overflow: Point<typeof Overflow[keyof typeof Overflow]> = {
+ *   x: Overflow.Hidden,
+ *   y: Overflow.Scroll
+ * };
+ *
+ * style.overflow = overflow;
+ * ```
+ */
+export interface Point<T> {
+  /** The horizontal (x-axis) value */
+  x: T;
+  /** The vertical (y-axis) value */
+  y: T;
+}
+
+/**
+ * Rectangle with left, right, top, and bottom values.
+ *
+ * Used for box model properties like `margin`, `padding`, `border`, and `inset`.
+ *
+ * @typeParam T - The type of each side value
+ *
+ * @property left - The left side value
+ * @property right - The right side value
+ * @property top - The top side value
+ * @property bottom - The bottom side value
+ *
+ * @example
+ * ```typescript
+ * import { Style, type Rect, type LengthPercentage, type LengthPercentageAuto } from 'taffy-js';
+ *
+ * const style = new Style();
+ *
+ * // Typed padding
+ * const padding: Rect<LengthPercentage> = {
+ *   left: 10,
+ *   right: 10,
+ *   top: 10,
+ *   bottom: 10
+ * };
+ *
+ * // Typed margin with auto
+ * const margin: Rect<LengthPercentageAuto> = {
+ *   left: "auto",
+ *   right: "auto",
+ *   top: 10,
+ *   bottom: 30
+ * };
+ *
+ * style.padding = padding;
+ * style.margin = margin;
+ * ```
+ */
+export interface Rect<T> {
+  /** The left side value */
+  left: T;
+  /** The right side value */
+  right: T;
+  /** The top side value */
+  top: T;
+  /** The bottom side value */
+  bottom: T;
+}
+
+/**
+ * Detailed layout information (for grid layouts).
+ *
+ * Returned by `detailedLayoutInfo()` for nodes using CSS Grid layout.
+ * Contains detailed information about grid tracks and item placement.
+ *
+ * @remarks
+ * This is only available when the `detailed_layout_info` feature is enabled.
+ *
+ * @example
+ * ```typescript
+ * import type { DetailedLayoutInfo, DetailedGridInfo } from 'taffy-js';
+ *
+ * const info: DetailedLayoutInfo = tree.detailedLayoutInfo(gridNode);
+ *
+ * if (info !== "None" && typeof info === 'object' && 'Grid' in info) {
+ *   const grid: DetailedGridInfo = info.Grid;
+ *   console.log('Rows:', grid.rows.sizes);
+ *   console.log('Columns:', grid.columns.sizes);
+ * }
+ * ```
+ */
+export type DetailedLayoutInfo = DetailedGridInfo | null;
+
+/**
+ * Detailed information about a grid layout.
+ *
+ * Contains information about grid rows, columns, and item placement.
+ *
+ * @property rows - Information about row tracks
+ * @property columns - Information about column tracks
+ * @property items - Array of item placement information
+ */
+export interface DetailedGridInfo {
+  /** Information about the grid's row tracks */
+  rows: DetailedGridTracksInfo;
+  /** Information about the grid's column tracks */
+  columns: DetailedGridTracksInfo;
+  /** Placement information for each grid item */
+  items: DetailedGridItemsInfo[];
+}
+
+/**
+ * Information about grid tracks (rows or columns).
+ *
+ * Provides detailed sizing and gutter information for a set of grid tracks.
+ *
+ * @property negative_implicit_tracks - Number of implicit tracks before explicit tracks
+ * @property explicit_tracks - Number of explicitly defined tracks
+ * @property positive_implicit_tracks - Number of implicit tracks after explicit tracks
+ * @property gutters - Array of gutter sizes between tracks (in pixels)
+ * @property sizes - Array of track sizes (in pixels)
+ */
+export interface DetailedGridTracksInfo {
+  /** Number of implicit tracks before explicit tracks (for negative line numbers) */
+  negative_implicit_tracks: number;
+  /** Number of tracks explicitly defined in grid-template-rows/columns */
+  explicit_tracks: number;
+  /** Number of implicit tracks created after explicit tracks */
+  positive_implicit_tracks: number;
+  /** Gap sizes between tracks in pixels */
+  gutters: number[];
+  /** Computed sizes of each track in pixels */
+  sizes: number[];
+}
+
+/**
+ * Information about a grid item's placement.
+ *
+ * Specifies which grid lines the item spans on both axes.
+ * Line numbers are 1-indexed, with 1 being the first line.
+ *
+ * @property row_start - Starting row line number (1-indexed)
+ * @property row_end - Ending row line number (exclusive)
+ * @property column_start - Starting column line number (1-indexed)
+ * @property column_end - Ending column line number (exclusive)
+ */
+export interface DetailedGridItemsInfo {
+  /** Starting row line (1-indexed) */
+  row_start: number;
+  /** Ending row line (exclusive) */
+  row_end: number;
+  /** Starting column line (1-indexed) */
+  column_start: number;
+  /** Ending column line (exclusive) */
+  column_end: number;
+}
+
+/**
+ * Multi-line content alignment enumeration
+ *
+ * Controls the distribution of space between and around content items along the cross axis
+ * in a multi-line flex container. This corresponds to the CSS `align-content` property.
+ *
+ * **Note**: This property only has effect when `flex-wrap` is set to `Wrap` or `WrapReverse`.
+ *
+ * @example
+ * ```typescript
+ * import { AlignContent, FlexWrap } from 'taffy-js';
+ *
+ * style.flexWrap = FlexWrap.Wrap;
+ * style.alignContent = AlignContent.SpaceBetween;  // Distribute lines evenly
+ * ```
+ */
+export enum AlignContent {
+  /**
+   * Lines packed toward the start of the cross axis
+   */
+  Start = 0,
+  /**
+   * Lines packed toward the end of the cross axis
+   */
+  End = 1,
+  /**
+   * Lines packed toward the start of the flex container
+   */
+  FlexStart = 2,
+  /**
+   * Lines packed toward the end of the flex container
+   */
+  FlexEnd = 3,
+  /**
+   * Lines centered within the container
+   */
+  Center = 4,
+  /**
+   * Lines stretched to fill the container
+   */
+  Stretch = 5,
+  /**
+   * Lines evenly distributed with first/last at edges
+   */
+  SpaceBetween = 6,
+  /**
+   * Lines evenly distributed with equal space around each
+   */
+  SpaceAround = 7,
+  /**
+   * Lines evenly distributed with equal space between each
+   */
+  SpaceEvenly = 8,
+}
+
+/**
+ * Cross-axis alignment enumeration for all children
+ *
+ * Defines the default alignment for all flex/grid items along the cross axis.
+ * This corresponds to the CSS `align-items` property.
+ *
+ * @example
+ * ```typescript
+ * import { AlignItems } from 'taffy-js';
+ *
+ * style.alignItems = AlignItems.Center;   // Center items on cross axis
+ * style.alignItems = AlignItems.Stretch;  // Stretch items to fill container
+ * ```
+ */
+export enum AlignItems {
+  /**
+   * Items aligned to the start of the cross axis
+   */
+  Start = 0,
+  /**
+   * Items aligned to the end of the cross axis
+   */
+  End = 1,
+  /**
+   * Items aligned to the start of the flex container
+   */
+  FlexStart = 2,
+  /**
+   * Items aligned to the end of the flex container
+   */
+  FlexEnd = 3,
+  /**
+   * Items centered along the cross axis
+   */
+  Center = 4,
+  /**
+   * Items aligned to their text baselines
+   */
+  Baseline = 5,
+  /**
+   * Items stretched to fill the container
+   */
+  Stretch = 6,
+}
+
+/**
+ * Cross-axis alignment enumeration for a single element
+ *
+ * Overrides the parent's `align-items` value for a specific child element.
+ * This corresponds to the CSS `align-self` property.
+ *
+ * @example
+ * ```typescript
+ * import { AlignSelf } from 'taffy-js';
+ *
+ * style.alignSelf = AlignSelf.Auto;    // Use parent's align-items
+ * style.alignSelf = AlignSelf.Center;  // Override to center this item
+ * ```
+ */
+export enum AlignSelf {
+  /**
+   * Inherits the parent container's `align-items` value
+   */
+  Auto = 0,
+  /**
+   * Item aligned to the start of the cross axis
+   */
+  Start = 1,
+  /**
+   * Item aligned to the end of the cross axis
+   */
+  End = 2,
+  /**
+   * Item aligned to the start of the flex container
+   */
+  FlexStart = 3,
+  /**
+   * Item aligned to the end of the flex container
+   */
+  FlexEnd = 4,
+  /**
+   * Item centered along the cross axis
+   */
+  Center = 5,
+  /**
+   * Item aligned to its text baseline
+   */
+  Baseline = 6,
+  /**
+   * Item stretched to fill the container
+   */
+  Stretch = 7,
+}
+
+/**
+ * Box sizing enumeration
+ *
+ * Controls how the total width and height of an element is calculated.
+ * This corresponds to the CSS `box-sizing` property.
+ *
+ * @example
+ * ```typescript
+ * import { BoxSizing } from 'taffy-js';
+ *
+ * style.boxSizing = BoxSizing.BorderBox;   // Size includes padding and border
+ * style.boxSizing = BoxSizing.ContentBox;  // Size is content only
+ * ```
+ */
+export enum BoxSizing {
+  /**
+   * The width and height properties include padding and border
+   */
+  BorderBox = 0,
+  /**
+   * The width and height properties include only the content
+   */
+  ContentBox = 1,
+}
+
+/**
+ * Display mode enumeration
+ *
+ * Controls the layout algorithm type for an element. This corresponds to the CSS `display` property
+ * and determines how an element and its children are laid out.
+ *
+ * @example
+ * ```typescript
+ * import { Display } from 'taffy-js';
+ *
+ * style.display = Display.Flex;  // Enable flexbox layout
+ * style.display = Display.Grid;  // Enable grid layout
+ * style.display = Display.None;  // Hide element from layout
+ * ```
+ */
+export enum Display {
+  /**
+   * Block-level layout where element takes the full available width
+   */
+  Block = 0,
+  /**
+   * Flexbox layout for one-dimensional item arrangement
+   */
+  Flex = 1,
+  /**
+   * CSS Grid layout for two-dimensional item arrangement
+   */
+  Grid = 2,
+  /**
+   * Element is removed from layout calculation entirely
+   */
+  None = 3,
+}
+
+/**
+ * Flex direction enumeration
+ *
+ * Defines the main axis direction for flex item layout. This corresponds to the CSS
+ * `flex-direction` property and determines how flex items are placed within the container.
+ *
+ * @example
+ * ```typescript
+ * import { FlexDirection } from 'taffy-js';
+ *
+ * style.flexDirection = FlexDirection.Row;     // Horizontal, left to right
+ * style.flexDirection = FlexDirection.Column;  // Vertical, top to bottom
+ * ```
+ */
+export enum FlexDirection {
+  /**
+   * Main axis runs horizontally from left to right
+   */
+  Row = 0,
+  /**
+   * Main axis runs vertically from top to bottom
+   */
+  Column = 1,
+  /**
+   * Main axis runs horizontally from right to left
+   */
+  RowReverse = 2,
+  /**
+   * Main axis runs vertically from bottom to top
+   */
+  ColumnReverse = 3,
+}
+
+/**
+ * Flex wrap mode enumeration
+ *
+ * Controls whether flex items wrap onto multiple lines when they overflow the container.
+ * This corresponds to the CSS `flex-wrap` property.
+ *
+ * @example
+ * ```typescript
+ * import { FlexWrap } from 'taffy-js';
+ *
+ * style.flexWrap = FlexWrap.NoWrap;  // All items on single line
+ * style.flexWrap = FlexWrap.Wrap;    // Items wrap to new lines
+ * ```
+ */
+export enum FlexWrap {
+  /**
+   * All flex items are placed on a single line
+   */
+  NoWrap = 0,
+  /**
+   * Flex items wrap onto multiple lines from top to bottom
+   */
+  Wrap = 1,
+  /**
+   * Flex items wrap onto multiple lines from bottom to top
+   */
+  WrapReverse = 2,
+}
+
+/**
+ * Main axis alignment enumeration
+ *
+ * Defines how flex items are aligned and spaced along the main axis.
+ * This corresponds to the CSS `justify-content` property.
+ *
+ * @example
+ * ```typescript
+ * import { JustifyContent } from 'taffy-js';
+ *
+ * style.justifyContent = JustifyContent.Center;        // Center items
+ * style.justifyContent = JustifyContent.SpaceBetween;  // Distribute evenly
+ * ```
+ */
+export enum JustifyContent {
+  /**
+   * Items packed toward the start of the main axis
+   */
+  Start = 0,
+  /**
+   * Items packed toward the end of the main axis
+   */
+  End = 1,
+  /**
+   * Items packed toward the start of the flex container
+   */
+  FlexStart = 2,
+  /**
+   * Items packed toward the end of the flex container
+   */
+  FlexEnd = 3,
+  /**
+   * Items centered along the main axis
+   */
+  Center = 4,
+  /**
+   * Items stretched along the main axis
+   */
+  Stretch = 5,
+  /**
+   * Items evenly distributed with first/last at edges
+   */
+  SpaceBetween = 6,
+  /**
+   * Items evenly distributed with equal space around each
+   */
+  SpaceAround = 7,
+  /**
+   * Items evenly distributed with equal space between each
+   */
+  SpaceEvenly = 8,
+}
+
+/**
+ * Computed layout result containing position, size, and spacing values for a node.
+ *
+ * This class wraps the native [`taffy::Layout`] and provides read-only access
+ * to all computed layout values. All dimensions are in pixels.
+ *
+ * @example
+ * ```typescript
+ * const layout = tree.getLayout(node);
+ *
+ * console.log("Position:", layout.x, layout.y);
+ * console.log("Size:", layout.width, layout.height);
+ * console.log("Content:", layout.contentWidth, layout.contentHeight);
+ * console.log("Padding:", layout.paddingTop, layout.paddingRight, layout.paddingBottom, layout.paddingLeft);
+ * console.log("Border:", layout.borderTop, layout.borderRight, layout.borderBottom, layout.borderLeft);
+ * console.log("Margin:", layout.marginTop, layout.marginRight, layout.marginBottom, layout.marginLeft);
+ * console.log("Scrollbar:", layout.scrollbarWidth, layout.scrollbarHeight);
+ * console.log("Order:", layout.order);
+ * ```
+ */
+export class Layout {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Gets the top border width
+   *
+   * @returns - The computed top border width in pixels
+   */
+  readonly borderTop: number;
+  /**
+   * Gets the top margin
+   *
+   * @returns - The computed top margin in pixels
+   */
+  readonly marginTop: number;
+  /**
+   * Gets the left border width
+   *
+   * @returns - The computed left border width in pixels
+   */
+  readonly borderLeft: number;
+  /**
+   * Gets the left margin
+   *
+   * @returns - The computed left margin in pixels
+   */
+  readonly marginLeft: number;
+  /**
+   * Gets the top padding
+   *
+   * @returns - The computed top padding in pixels
+   */
+  readonly paddingTop: number;
+  /**
+   * Gets the right border width
+   *
+   * @returns - The computed right border width in pixels
+   */
+  readonly borderRight: number;
+  /**
+   * Gets the right margin
+   *
+   * @returns - The computed right margin in pixels
+   */
+  readonly marginRight: number;
+  /**
+   * Gets the left padding
+   *
+   * @returns - The computed left padding in pixels
+   */
+  readonly paddingLeft: number;
+  /**
+   * Gets the bottom border width
+   *
+   * @returns - The computed bottom border width in pixels
+   */
+  readonly borderBottom: number;
+  /**
+   * Gets the width of the scrollable content
+   *
+   * If the node has overflow content, this represents the total
+   * width of all content (may exceed `width`).
+   *
+   * @returns - The content width in pixels
+   */
+  readonly contentWidth: number;
+  /**
+   * Gets the bottom margin
+   *
+   * @returns - The computed bottom margin in pixels
+   */
+  readonly marginBottom: number;
+  /**
+   * Gets the right padding
+   *
+   * @returns - The computed right padding in pixels
+   */
+  readonly paddingRight: number;
+  /**
+   * Gets the height of the scrollable content
+   *
+   * If the node has overflow content, this represents the total
+   * height of all content (may exceed `height`).
+   *
+   * @returns - The content height in pixels
+   */
+  readonly contentHeight: number;
+  /**
+   * Gets the bottom padding
+   *
+   * @returns - The computed bottom padding in pixels
+   */
+  readonly paddingBottom: number;
+  /**
+   * Gets the width of the vertical scrollbar
+   *
+   * When overflow is set to scroll, this indicates the space
+   * reserved for the vertical scrollbar.
+   *
+   * @returns - The scrollbar width in pixels (0 if no scrollbar)
+   */
+  readonly scrollbarWidth: number;
+  /**
+   * Gets the height of the horizontal scrollbar
+   *
+   * When overflow is set to scroll, this indicates the space
+   * reserved for the horizontal scrollbar.
+   *
+   * @returns - The scrollbar height in pixels (0 if no scrollbar)
+   */
+  readonly scrollbarHeight: number;
+  /**
+   * Gets the X coordinate of the node's top-left corner
+   *
+   * This value is relative to the node's parent. For the root node,
+   * this is always 0.
+   *
+   * @returns - The horizontal position in pixels
+   */
+  readonly x: number;
+  /**
+   * Gets the Y coordinate of the node's top-left corner
+   *
+   * This value is relative to the node's parent. For the root node,
+   * this is always 0.
+   *
+   * @returns - The vertical position in pixels
+   */
+  readonly y: number;
+  /**
+   * Gets the rendering order of the node
+   *
+   * This value determines the z-order for overlapping elements.
+   * Lower values are rendered first (behind higher values).
+   *
+   * @returns - The rendering order as an unsigned 32-bit integer
+   */
+  readonly order: number;
+  /**
+   * Gets the computed width of the node
+   *
+   * This is the final width after layout computation, including
+   * any constraints from min/max size or flex properties.
+   *
+   * @returns - The width in pixels
+   */
+  readonly width: number;
+  /**
+   * Gets the computed height of the node
+   *
+   * This is the final height after layout computation, including
+   * any constraints from min/max size or flex properties.
+   *
+   * @returns - The height in pixels
+   */
+  readonly height: number;
+}
+
+/**
+ * Overflow handling enumeration
+ *
+ * Defines how content that exceeds the container boundaries is handled.
+ * This corresponds to the CSS `overflow` property.
+ *
+ * @example
+ * ```typescript
+ * import { Overflow } from 'taffy-js';
+ *
+ * style.overflow = { x: Overflow.Hidden, y: Overflow.Scroll };
+ * ```
+ */
+export enum Overflow {
+  /**
+   * Content is not clipped and may render outside the container
+   */
+  Visible = 0,
+  /**
+   * Content is clipped at the container boundary
+   */
+  Hidden = 1,
+  /**
+   * Always display scrollbars for scrollable content
+   */
+  Scroll = 2,
+  /**
+   * Display scrollbars only when content overflows (internally maps to Scroll)
+   */
+  Auto = 3,
+}
+
+/**
+ * Position mode enumeration
+ *
+ * Controls how an element is positioned within its parent container.
+ * This corresponds to the CSS `position` property.
+ *
+ * @example
+ * ```typescript
+ * import { Position } from 'taffy-js';
+ *
+ * style.position = Position.Relative;  // Normal document flow
+ * style.position = Position.Absolute;  // Removed from flow, uses inset values
+ * ```
+ */
+export enum Position {
+  /**
+   * Element participates in normal document flow
+   */
+  Relative = 0,
+  /**
+   * Element is positioned relative to its nearest positioned ancestor
+   */
+  Absolute = 1,
+}
+
+/**
+ * CSS layout configuration for a node, including flexbox, sizing, spacing, and alignment properties.
+ *
+ * This class holds all CSS layout properties for a node. Create an instance with
+ * `new Style()` and configure properties before passing to `TaffyTree.newLeaf()`.
+ *
+ * @defaultValue
+ * When created, all properties are set to their CSS default values:
+ * - `display`: `Display.Block`
+ * - `position`: `Position.Relative`
+ * - `flexDirection`: `FlexDirection.Row`
+ * - `flexWrap`: `FlexWrap.NoWrap`
+ * - `flexGrow`: `0`
+ * - `flexShrink`: `1`
+ * - All alignment properties: `undefined` (use default behavior)
+ * - All dimensions: `"Auto"`
+ * - All spacing: `{ Length: 0 }`
+ *
+ */
+export class Style {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Creates a new Style instance with default values
+   *
+   * @returns - A new `Style` object with all properties set to CSS defaults
+   *
+   * @example
+   * ```typescript
+   * const style = new Style();
+   * console.log(style.display);  // Display.Block
+   * ```
+   */
+  constructor();
+  /**
+   * Gets the align-self property
+   *
+   * Overrides the parent's align-items for this specific element.
+   *
+   * @returns - The current [`AlignSelf`](JsAlignSelf) value (returns `Auto` if not set)
+   */
+  alignSelf: AlignSelf | undefined;
+  /**
+   * Gets the box sizing mode
+   *
+   * Determines whether padding and border are included in dimensions.
+   *
+   * @returns - The current [`BoxSizing`](JsBoxSizing) value
+   *
+   * @defaultValue `BoxSizing.BorderBox`
+   */
+  boxSizing: BoxSizing;
+  /**
+   * Gets the flex-basis
+   *
+   * The initial size of a flex item before growing/shrinking.
+   *
+   * @returns - A `Dimension` value (`{ Length: n }`, `{ Percent: n }`, or `"Auto"`)
+   */
+  flexBasis: Dimension;
+  /**
+   * Gets the border width
+   *
+   * Width of the element's border on each side.
+   *
+   * @returns - A `Rect<LengthPercentage>` with left, right, top, bottom border widths
+   */
+  border: Rect<LengthPercentage>;
+  /**
+   * Gets the margin
+   *
+   * Outer spacing around the element.
+   *
+   * @returns - A `Rect<LengthPercentageAuto>` with left, right, top, bottom margins
+   */
+  margin: Rect<LengthPercentageAuto>;
+  /**
+   * Gets the align-items property
+   *
+   * Defines the default alignment for all children on the cross axis.
+   *
+   * @returns - The current [`AlignItems`](JsAlignItems) value, or `undefined` if not set
+   */
+  alignItems: AlignItems | undefined;
+  /**
+   * Gets the flex shrink factor
+   *
+   * Determines how much the item shrinks relative to siblings when
+   * there is insufficient space.
+   *
+   * @returns - The flex shrink factor (default: 1)
+   */
+  flexShrink: number;
+  /**
+   * Gets the display mode
+   *
+   * Determines the layout algorithm used for this element and its children.
+   *
+   * @returns - The current [`Display`](JsDisplay) value
+   *
+   * @defaultValue - `Display.Block`
+   */
+  display: Display;
+  /**
+   * Gets the padding
+   *
+   * Inner spacing between the element's border and content.
+   *
+   * @returns - A `Rect<LengthPercentage>` with left, right, top, bottom padding
+   */
+  padding: Rect<LengthPercentage>;
+  /**
+   * Gets the aspect ratio
+   *
+   * The ratio of width to height. Used to maintain proportions.
+   *
+   * @returns - The aspect ratio value, or `undefined` if not set
+   */
+  aspectRatio: number | undefined;
+  /**
+   * Gets the maximum size constraints
+   *
+   * @returns - A `Size<Dimension>` object with maximum width and height
+   */
+  maxSize: Size<Dimension>;
+  /**
+   * Gets the minimum size constraints
+   *
+   * @returns - A `Size<Dimension>` object with minimum width and height
+   */
+  minSize: Size<Dimension>;
+  /**
+   * Gets the overflow behavior
+   *
+   * Controls how content that exceeds the container is handled.
+   *
+   * @returns - A `Point<Overflow>` with `x` and `y` overflow settings
+   */
+  overflow: Point<Overflow>;
+  /**
+   * Gets the position mode
+   *
+   * Determines how the element is positioned within its parent.
+   *
+   * @returns - The current [`Position`](JsPosition) value
+   *
+   * @defaultValue - `Position.Relative`
+   */
+  position: Position;
+  /**
+   * Gets the align-content property
+   *
+   * Controls distribution of space between lines in a multi-line flex container.
+   *
+   * @returns - The current [`AlignContent`](JsAlignContent) value, or `undefined` if not set
+   */
+  alignContent: AlignContent | undefined;
+  /**
+   * Gets the flex grow factor
+   *
+   * Determines how much the item grows relative to siblings when
+   * there is extra space available.
+   *
+   * @returns - The flex grow factor (default: 0)
+   */
+  flexGrow: number;
+  /**
+   * Gets the flex wrap mode
+   *
+   * Controls whether flex items wrap to new lines.
+   *
+   * @returns - The current [`FlexWrap`](JsFlexWrap) value
+   *
+   * @defaultValue - `FlexWrap.NoWrap`
+   */
+  flexWrap: FlexWrap;
+  /**
+   * Gets the flex direction
+   *
+   * Defines the main axis direction for flex items.
+   *
+   * @returns - The current [`FlexDirection`](JsFlexDirection) value
+   *
+   * @defaultValue - `FlexDirection.Row`
+   */
+  flexDirection: FlexDirection;
+  /**
+   * Gets the justify-content property
+   *
+   * Defines alignment and spacing of items along the main axis.
+   *
+   * @returns - The current [`JustifyContent`](JsJustifyContent) value, or `undefined` if not set
+   */
+  justifyContent: JustifyContent | undefined;
+  /**
+   * Gets the gap
+   *
+   * Spacing between flex/grid items.
+   *
+   * @returns - A `Size<LengthPercentage>` with column (width) and row (height) gaps
+   */
+  gap: Size<LengthPercentage>;
+  /**
+   * Gets the size (width and height)
+   *
+   * @returns - A `Size<Dimension>` object with `width` and `height` properties
+   */
+  size: Size<Dimension>;
+  /**
+   * Gets the inset
+   *
+   * Positioning offsets for absolutely positioned elements.
+   *
+   * @returns - A `Rect<LengthPercentageAuto>` with left, right, top, bottom offsets
+   */
+  inset: Rect<LengthPercentageAuto>;
+}
+
+/**
+ * Error class thrown when a Taffy operation fails, containing a human-readable error message.
+ *
+ * This class wraps the native [`taffy::TaffyError`] type and exposes it to JavaScript
+ * with a readable error message. It is thrown as a JavaScript exception on failure.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *  tree.remove(node);
+ * } catch (e) {
+ *   if (e instanceof TaffyError) {
+ *      console.error(e.message);
+ *   }
+ * }
+ * ```
+ *
+ * @remarks
+ * The underlying Taffy errors include:
+ * - `InvalidInputNode`: Node ID doesn't exist in the tree
+ * - `InvalidParentNode`: Specified parent node doesn't exist
+ * - `ChildIndexOutOfBounds`: Child index exceeds available children
+ */
+export class TaffyError {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Gets the human-readable error message
+   *
+   * @returns - A string describing what went wrong.
+   *
+   * @remarks
+   * Examples:
+   * - "Node with id 1234 is not present in the Taffy tree"
+   * - "Index 5 is out of bounds for node with 3 children"
+   */
+  readonly message: string;
+}
+
+/**
+ * The main layout tree class for creating nodes, computing layouts, and managing a tree of styled elements.
+ *
+ * TaffyTree is the entry point for the Taffy layout engine. It manages
+ * a tree of nodes and computes their layouts using CSS Flexbox and Grid algorithms.
+ *
+ */
+export class TaffyTree {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Marks a node as dirty (requiring re-layout)
+   *
+   * Use this when a node's content has changed but its style hasn't.
+   * For example, when text content changes and needs remeasuring.
+   *
+   * @param node - The node ID to mark dirty
+   *
+   * @throws `TaffyError` if the node does not exist
+   *
+   * @example
+   * ```typescript
+   * // After updating text content
+   * tree.setNodeContext(nodeId, { text: "Updated text" });
+   * tree.markDirty(nodeId);
+   * tree.computeLayout(rootId, availableSpace);
+   * ```
+   */
+  markDirty(node: bigint): void;
+  /**
+   * Prints the tree structure to the console (for debugging)
+   *
+   * Outputs a text representation of the tree structure starting from
+   * the given node. Useful for debugging layout issues.
+   *
+   * @param node - The root node ID to print from
+   *
+   * @example
+   * ```typescript
+   * tree.printTree(rootId);
+   * // Output appears in browser console
+   * ```
+   */
+  printTree(node: bigint): void;
+  /**
+   * Gets the number of children of a node
+   *
+   * @param parent - The parent node ID
+   *
+   * @returns - The number of direct children
+   *
+   * @throws `TaffyError` if the node does not exist
+   *
+   * @example
+   * ```typescript
+   * const count: number = tree.childCount(parentId);
+   * ```
+   */
+  childCount(parent: bigint): number;
+  /**
+   * Removes a specific child from a parent
+   *
+   * @param parent - The parent node ID
+   * @param child - The child node ID to remove
+   *
+   * @returns - The removed child ID (`bigint`)
+   *
+   * @throws `TaffyError` if the parent or child node does not exist
+   *
+   * @example
+   * ```typescript
+   * tree.removeChild(parentId, childId);
+   * ```
+   */
+  removeChild(parent: bigint, child: bigint): bigint;
+  /**
+   * Replaces all children of a node
+   *
+   * Any existing children are removed and replaced with the new array.
+   *
+   * @param parent - The parent node ID
+   * @param children - Array of new child node IDs
+   *
+   * @throws `TaffyError` if the parent node does not exist
+   *
+   * @example
+   * ```typescript
+   * const children = BigUint64Array.from([child1, child2, child3]);
+   * tree.setChildren(parentId, children);
+   * ```
+   */
+  setChildren(parent: bigint, children: BigUint64Array): void;
+  /**
+   * Creates a new TaffyTree with pre-allocated capacity
+   *
+   * Use this when you know approximately how many nodes will be in the tree.
+   * This can improve performance by reducing memory reallocations.
+   *
+   * @param capacity - The number of nodes to pre-allocate space for
+   *
+   * @example
+   * ```typescript
+   * const tree: TaffyTree = TaffyTree.withCapacity(1000);
+   * ```
+   */
+  static withCapacity(capacity: number): TaffyTree;
+  /**
+   * Computes the layout for a subtree
+   *
+   * This is the main layout computation method. Call this on the root node
+   * to compute layouts for all nodes in the tree.
+   *
+   * @param node - The root node ID to compute layout for
+   * @param available_space - The available space constraints
+   *
+   * @example
+   * ```typescript
+   * // Fixed size container
+   * { width: { Definite: 800 }, height: { Definite: 600 } }
+   *
+   * // Flexible width, fixed height
+   * { width: "MaxContent", height: { Definite: 600 } }
+   *
+   * // Minimum content size
+   * { width: "MinContent", height: "MinContent" }
+   * ```
+   *
+   * @throws `TaffyError` if the node does not exist or available space is invalid
+   *
+   * @example
+   * ```typescript
+   * tree.computeLayout(rootId, { width: { Definite: 800 }, height: { Definite: 600 } });
+   * ```
+   */
+  computeLayout(node: bigint, available_space: Size<AvailableSpace>): void;
+  /**
+   * Enables rounding of layout values to whole pixels
+   *
+   * When enabled (default), computed layout values like position and size
+   * are rounded to the nearest integer. This prevents sub-pixel rendering
+   * issues in most rendering contexts.
+   *
+   * @example
+   * ```typescript
+   * tree.enableRounding();
+   * ```
+   */
+  enableRounding(): void;
+  /**
+   * Disables rounding of layout values
+   *
+   * When disabled, computed layout values retain their fractional precision.
+   * Use this when you need sub-pixel accuracy or when performing custom
+   * rounding.
+   *
+   * @example
+   * ```typescript
+   * tree.disableRounding();
+   * const layout = tree.getLayout(node);
+   * console.log(layout.x);
+   * ```
+   */
+  disableRounding(): void;
+  /**
+   * Gets the context value for a node
+   *
+   * @param node - The node ID
+   *
+   * @returns - The attached context value, or `undefined` if none is set
+   *
+   * @example
+   * ```typescript
+   * interface Context { text: string };
+   * const context = tree.getNodeContext(nodeId) as Context | undefined;
+   * if (context) {
+   *   console.log(context.text);
+   * }
+   * ```
+   */
+  getNodeContext(node: bigint): any;
+  /**
+   * Sets a context value for a node
+   *
+   * The context can be any JavaScript value and is passed to the measure
+   * function during layout computation.
+   *
+   * @param node - The node ID
+   * @param context - Any JavaScript value to attach
+   *
+   * @throws `TaffyError` if the node does not exist
+   *
+   * @example
+   * ```typescript
+   * interface Context { text: string };
+   * tree.setNodeContext(nodeId, { text: "Updated text" } as Context);
+   * ```
+   */
+  setNodeContext(node: bigint, context: any): void;
+  /**
+   * Gets the total number of nodes in the tree
+   *
+   * @returns - The total count of all nodes
+   *
+   * @example
+   * ```typescript
+   * const count: number = tree.totalNodeCount();
+   * ```
+   */
+  totalNodeCount(): number;
+  /**
+   * Gets the unrounded (fractional) layout for a node
+   *
+   * Returns the raw computed values before any rounding is applied.
+   * Useful when you need sub-pixel precision.
+   *
+   * @param node - The node ID
+   *
+   * @returns - The unrounded `Layout`
+   *
+   * @example
+   * ```typescript
+   * const layout: Layout = tree.unroundedLayout(nodeId);
+   * console.log(`Exact width: ${layout.width}`);
+   * ```
+   */
+  unroundedLayout(node: bigint): Layout;
+  /**
+   * Creates a new node with the given children
+   *
+   * Use this to create container nodes that have child elements.
+   * The children must already exist in the tree.
+   *
+   * @param style - The style configuration for the node
+   * @param children - Array of child node IDs (as BigUint64Array)
+   *
+   * @returns - The node ID (`bigint`)
+   *
+   * @throws `TaffyError` if the node cannot be created
+   *
+   * @example
+   * ```typescript
+   * const containerStyle = new Style();
+   * containerStyle.display = Display.Flex;
+   *
+   * const child1: bigint = tree.newLeaf(new Style());
+   * const child2: bigint = tree.newLeaf(new Style());
+   *
+   * const container: bigint = tree.newWithChildren(
+   *   containerStyle,
+   *   BigUint64Array.from([child1, child2])
+   * );
+   * ```
+   */
+  newWithChildren(style: Style, children: BigUint64Array): bigint;
+  /**
+   * Gets the child at a specific index
+   *
+   * @param parent - The parent node ID
+   * @param index - The index of the child (0-based)
+   *
+   * @returns - The child node ID (`bigint`)
+   *
+   * @throws `TaffyError` if the parent node does not exist or index is out of bounds
+   *
+   * @example
+   * ```typescript
+   * const firstChild: bigint = tree.getChildAtIndex(parentId, 0);
+   * ```
+   */
+  getChildAtIndex(parent: bigint, index: number): bigint;
+  /**
+   * Gets a mutable reference to the context value for a node
+   *
+   * In JavaScript, this behaves the same as `getNodeContext()` since
+   * JavaScript objects are always passed by reference.
+   *
+   * @param node - The node ID
+   *
+   * @returns - The attached context value, or `undefined` if none is set
+   */
+  getNodeContextMut(node: bigint): any;
+  /**
+   * Inserts a child at a specific index
+   *
+   * @param parent - The parent node ID
+   * @param index - The position to insert at (0-based)
+   * @param child - The child node ID to insert
+   *
+   * @throws `TaffyError` if the parent or child node does not exist, or index is out of bounds
+   *
+   * @example
+   * ```typescript
+   * tree.insertChildAtIndex(parentId, 0, childId);
+   * ```
+   */
+  insertChildAtIndex(parent: bigint, index: number, child: bigint): void;
+  /**
+   * Creates a new leaf node with an attached context value
+   *
+   * The context can be any JavaScript value and is passed to the measure
+   * function during layout computation. This is useful for storing
+   * references to text content or other dynamic data.
+   *
+   * @param style - The style configuration for the node
+   * @param context - Any JavaScript value to attach to the node
+   * @returns - The node ID (`bigint`)
+   * @throws `TaffyError` if the node cannot be created
+   *
+   * @example
+   * ```typescript
+   * interface TextContext { text: string; isBold: boolean; }
+   *
+   * const style = new Style();
+   * const context: TextContext = { text: "Hello, World!", isBold: true };
+   * const nodeId: bigint = tree.newLeafWithContext(style, context);
+   * ```
+   */
+  newLeafWithContext(style: Style, context: any): bigint;
+  /**
+   * Removes a child at a specific index
+   *
+   * @param parent - The parent node ID
+   * @param index - The index of the child to remove (0-based)
+   *
+   * @returns - The removed child ID (`bigint`)
+   *
+   * @throws `TaffyError` if the parent node does not exist or index is out of bounds
+   *
+   * @example
+   * ```typescript
+   * const removedId: bigint = tree.removeChildAtIndex(parentId, 0);
+   * ```
+   */
+  removeChildAtIndex(parent: bigint, index: number): bigint;
+  /**
+   * Removes a range of children
+   *
+   * Removes children from `start_index` (inclusive) to `end_index` (exclusive).
+   *
+   * @param parent - The parent node ID
+   * @param start_index - Start of range (inclusive)
+   * @param end_index - End of range (exclusive)
+   *
+   * @throws `TaffyError` if the parent node does not exist or range is invalid
+   *
+   * @example
+   * ```typescript
+   * tree.removeChildrenRange(parentId, 1, 3);
+   * ```
+   */
+  removeChildrenRange(
+    parent: bigint,
+    start_index: number,
+    end_index: number,
+  ): void;
+  /**
+   * Replaces a child at a specific index
+   *
+   * @param parent - The parent node ID
+   * @param index - The index of the child to replace (0-based)
+   * @param new_child - The new child node ID
+   *
+   * @returns - The replaced (old) child ID (`bigint`)
+   *
+   * @throws `TaffyError` if the parent node does not exist or index is out of bounds
+   *
+   * @example
+   * ```typescript
+   * const oldChildId: bigint = tree.replaceChildAtIndex(parentId, 1, newChildId);
+   * ```
+   */
+  replaceChildAtIndex(parent: bigint, index: number, new_child: bigint): bigint;
+  /**
+   * Computes layout with a custom measure function for leaf nodes
+   *
+   * Use this when you have leaf nodes with dynamic content (like text)
+   * that needs to be measured during layout. The measure function is
+   * called for each leaf node that needs measurement.
+   *
+   * @param node - The root node ID to compute layout for
+   * @param available_space - The available space constraints
+   * @param measure_func - A function that measures leaf node content
+   *
+   * @throws `TaffyError` if the node does not exist or available space is invalid
+   *
+   * @example
+   * ```typescript
+   * tree.computeLayoutWithMeasure(
+   *   rootId,
+   *   { width: { Definite: 800 }, height: "MaxContent" },
+   *   (known, available, node, context, style) => {
+   *     if (context?.text) {
+   *       const measured = measureText(context.text, available.width);
+   *       return { width: measured.width, height: measured.height };
+   *     }
+   *     return { width: 0, height: 0 };
+   *   }
+   * );
+   * ```
+   */
+  computeLayoutWithMeasure(
+    node: bigint,
+    available_space: Size<AvailableSpace>,
+    measure_func: MeasureFunction,
+  ): void;
+  /**
+   * Gets context values for multiple nodes at once
+   *
+   * This is more efficient than calling `getNodeContext()` multiple times
+   * when you need to access contexts for many nodes.
+   *
+   * @param children - Array of node IDs
+   *
+   * @returns - Array of context values (undefined for nodes without context)
+   *
+   * @example
+   * ```typescript
+   * const nodes = BigUint64Array.from([id1, id2]);
+   * const contexts = tree.getDisjointNodeContextMut(nodes);
+   * ```
+   */
+  getDisjointNodeContextMut(children: BigUint64Array): any[];
+  /**
+   * Creates a new empty TaffyTree
+   *
+   * The tree starts with no nodes. Use `newLeaf()` or `newWithChildren()`
+   * to add nodes.
+   *
+   * @example
+   * ```typescript
+   * const tree: TaffyTree = new TaffyTree();
+   * ```
+   */
+  constructor();
+  /**
+   * Removes all nodes from the tree
+   *
+   * This clears the entire tree, removing all nodes and their relationships.
+   * Use this to reset the tree for reuse.
+   *
+   * @example
+   * ```typescript
+   * tree.clear();
+   * console.log(tree.totalNodeCount());
+   * ```
+   */
+  clear(): void;
+  /**
+   * Checks if a node is dirty (needs re-layout)
+   *
+   * A node is dirty if its style or content has changed since the last
+   * layout computation.
+   *
+   * @param node - The node ID to check
+   *
+   * @returns - true if dirty, false otherwise
+   *
+   * @throws `TaffyError` if the node does not exist
+   *
+   * @example
+   * ```typescript
+   * if (tree.dirty(nodeId)) {
+   *   tree.computeLayout(rootId, availableSpace);
+   * }
+   * ```
+   */
+  dirty(node: bigint): boolean;
+  /**
+   * Gets the style for a node
+   *
+   * @param node - The node ID
+   *
+   * @returns - The node's `Style`
+   *
+   * @throws `TaffyError` if the node does not exist
+   *
+   * @example
+   * ```typescript
+   * const style: Style = tree.getStyle(nodeId);
+   * console.log('Flex grow:', style.flexGrow);
+   * ```
+   */
+  getStyle(node: bigint): Style;
+  /**
+   * Gets the computed layout for a node
+   *
+   * Call this after `computeLayout()` to retrieve the computed position
+   * and size for a node.
+   *
+   * @param node - The node ID
+   *
+   * @returns - The computed `Layout`
+   *
+   * @throws `TaffyError` if the node does not exist
+   *
+   * @example
+   * ```typescript
+   * tree.computeLayout(rootId, { width: { Definite: 800 }, height: { Definite: 600 } });
+   * const layout: Layout = tree.getLayout(nodeId);
+   * console.log(`Position: (${layout.x}, ${layout.y}), Size: ${layout.width}x${layout.height}`);
+   * ```
+   */
+  getLayout(node: bigint): Layout;
+  /**
+   * Gets the parent of a node
+   *
+   * @param child - The child node ID
+   *
+   * @returns - The parent node ID, or `undefined` if the node has no parent
+   *
+   * @example
+   * ```typescript
+   * const parentId: bigint | undefined = tree.parent(childId);
+   * ```
+   */
+  parent(child: bigint): bigint | undefined;
+  /**
+   * Removes a node from the tree
+   *
+   * The node and all its descendants are removed. If the node has a parent,
+   * it is automatically removed from the parent's children.
+   *
+   * @param node - The node ID to remove
+   *
+   * @returns - The removed node ID (`bigint`)
+   *
+   * @throws `TaffyError` if the node does not exist
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   const removedId: bigint = tree.remove(nodeId);
+   * } catch (e) {
+   *   console.error("Node doesn't exist");
+   * }
+   * ```
+   */
+  remove(node: bigint): bigint;
+  /**
+   * Gets all children of a node
+   *
+   * @param parent - The parent node ID
+   *
+   * @returns - Array of child node IDs (`BigUint64Array`)
+   *
+   * @throws `TaffyError` if the parent node does not exist
+   *
+   * @example
+   * ```typescript
+   * const children: BigUint64Array = tree.children(parentId);
+   * ```
+   */
+  children(parent: bigint): BigUint64Array;
+  /**
+   * Creates a new leaf node with the given style
+   *
+   * A leaf node has no children. Use this for elements that contain
+   * content (like text) rather than other elements.
+   *
+   * @param style - The style configuration for the node
+   * @returns - The node ID (`bigint`)
+   * @throws `TaffyError` if the node cannot be created
+   *
+   * @example
+   * ```typescript
+   * const style = new Style();
+   * style.size = { width: { Length: 100 }, height: { Length: 50 } };
+   * const nodeId: bigint = tree.newLeaf(style);
+   * ```
+   */
+  newLeaf(style: Style): bigint;
+  /**
+   * Appends a child node to a parent
+   *
+   * The child is added as the last child of the parent.
+   *
+   * @param parent - The parent node ID
+   * @param child - The child node ID to add
+   *
+   * @throws `TaffyError` if the parent or child node does not exist
+   *
+   * @example
+   * ```typescript
+   * tree.addChild(parentId, childId);
+   * ```
+   */
+  addChild(parent: bigint, child: bigint): void;
+  /**
+   * Sets the style for an existing node
+   *
+   * This replaces the node's current style with the provided one.
+   * The node will be marked as dirty and require re-layout.
+   *
+   * @param node - The node ID
+   * @param style - The new style configuration
+   *
+   * @throws `TaffyError` if the node does not exist
+   *
+   * @example
+   * ```typescript
+   * const newStyle = new Style();
+   * newStyle.flexGrow = 2;
+   * tree.setStyle(nodeId, newStyle);
+   * ```
+   */
+  setStyle(node: bigint, style: Style): void;
+}
+
+export type InitInput =
+  | RequestInfo
+  | URL
+  | Response
+  | BufferSource
+  | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_layout_free: (a: number, b: number) => void;
+  readonly __wbg_style_free: (a: number, b: number) => void;
+  readonly __wbg_taffyerror_free: (a: number, b: number) => void;
+  readonly __wbg_taffytree_free: (a: number, b: number) => void;
+  readonly layout_borderBottom: (a: number) => number;
+  readonly layout_borderLeft: (a: number) => number;
+  readonly layout_borderRight: (a: number) => number;
+  readonly layout_borderTop: (a: number) => number;
+  readonly layout_contentHeight: (a: number) => number;
+  readonly layout_contentWidth: (a: number) => number;
+  readonly layout_height: (a: number) => number;
+  readonly layout_marginBottom: (a: number) => number;
+  readonly layout_marginLeft: (a: number) => number;
+  readonly layout_marginRight: (a: number) => number;
+  readonly layout_marginTop: (a: number) => number;
+  readonly layout_order: (a: number) => number;
+  readonly layout_paddingBottom: (a: number) => number;
+  readonly layout_paddingLeft: (a: number) => number;
+  readonly layout_paddingRight: (a: number) => number;
+  readonly layout_paddingTop: (a: number) => number;
+  readonly layout_scrollbarHeight: (a: number) => number;
+  readonly layout_scrollbarWidth: (a: number) => number;
+  readonly layout_width: (a: number) => number;
+  readonly layout_x: (a: number) => number;
+  readonly layout_y: (a: number) => number;
+  readonly style_alignContent: (a: number) => number;
+  readonly style_alignItems: (a: number) => number;
+  readonly style_alignSelf: (a: number) => number;
+  readonly style_aspectRatio: (a: number) => number;
+  readonly style_border: (a: number) => any;
+  readonly style_boxSizing: (a: number) => number;
+  readonly style_display: (a: number) => number;
+  readonly style_flexBasis: (a: number) => any;
+  readonly style_flexDirection: (a: number) => number;
+  readonly style_flexGrow: (a: number) => number;
+  readonly style_flexShrink: (a: number) => number;
+  readonly style_flexWrap: (a: number) => number;
+  readonly style_gap: (a: number) => any;
+  readonly style_inset: (a: number) => any;
+  readonly style_justifyContent: (a: number) => number;
+  readonly style_margin: (a: number) => any;
+  readonly style_maxSize: (a: number) => any;
+  readonly style_minSize: (a: number) => any;
+  readonly style_new: () => number;
+  readonly style_overflow: (a: number) => any;
+  readonly style_padding: (a: number) => any;
+  readonly style_position: (a: number) => number;
+  readonly style_set_alignContent: (a: number, b: any) => void;
+  readonly style_set_alignItems: (a: number, b: any) => void;
+  readonly style_set_alignSelf: (a: number, b: any) => void;
+  readonly style_set_aspectRatio: (a: number, b: any) => void;
+  readonly style_set_border: (a: number, b: any) => void;
+  readonly style_set_boxSizing: (a: number, b: number) => void;
+  readonly style_set_display: (a: number, b: number) => void;
+  readonly style_set_flexBasis: (a: number, b: any) => void;
+  readonly style_set_flexDirection: (a: number, b: number) => void;
+  readonly style_set_flexGrow: (a: number, b: number) => void;
+  readonly style_set_flexShrink: (a: number, b: number) => void;
+  readonly style_set_flexWrap: (a: number, b: number) => void;
+  readonly style_set_gap: (a: number, b: any) => void;
+  readonly style_set_inset: (a: number, b: any) => void;
+  readonly style_set_justifyContent: (a: number, b: any) => void;
+  readonly style_set_margin: (a: number, b: any) => void;
+  readonly style_set_maxSize: (a: number, b: any) => void;
+  readonly style_set_minSize: (a: number, b: any) => void;
+  readonly style_set_overflow: (a: number, b: any) => void;
+  readonly style_set_padding: (a: number, b: any) => void;
+  readonly style_set_position: (a: number, b: number) => void;
+  readonly style_set_size: (a: number, b: any) => void;
+  readonly style_size: (a: number) => any;
+  readonly taffyerror_message: (a: number) => [number, number];
+  readonly taffytree_addChild: (
+    a: number,
+    b: bigint,
+    c: bigint,
+  ) => [number, number];
+  readonly taffytree_childCount: (a: number, b: bigint) => number;
+  readonly taffytree_children: (
+    a: number,
+    b: bigint,
+  ) => [number, number, number, number];
+  readonly taffytree_clear: (a: number) => void;
+  readonly taffytree_computeLayout: (
+    a: number,
+    b: bigint,
+    c: any,
+  ) => [number, number];
+  readonly taffytree_computeLayoutWithMeasure: (
+    a: number,
+    b: bigint,
+    c: any,
+    d: any,
+  ) => [number, number];
+  readonly taffytree_dirty: (a: number, b: bigint) => [number, number, number];
+  readonly taffytree_disableRounding: (a: number) => void;
+  readonly taffytree_enableRounding: (a: number) => void;
+  readonly taffytree_getChildAtIndex: (
+    a: number,
+    b: bigint,
+    c: number,
+  ) => [bigint, number, number];
+  readonly taffytree_getDisjointNodeContextMut: (
+    a: number,
+    b: number,
+    c: number,
+  ) => [number, number, number, number];
+  readonly taffytree_getLayout: (
+    a: number,
+    b: bigint,
+  ) => [number, number, number];
+  readonly taffytree_getNodeContext: (
+    a: number,
+    b: bigint,
+  ) => [number, number, number];
+  readonly taffytree_getNodeContextMut: (
+    a: number,
+    b: bigint,
+  ) => [number, number, number];
+  readonly taffytree_getStyle: (
+    a: number,
+    b: bigint,
+  ) => [number, number, number];
+  readonly taffytree_insertChildAtIndex: (
+    a: number,
+    b: bigint,
+    c: number,
+    d: bigint,
+  ) => [number, number];
+  readonly taffytree_markDirty: (a: number, b: bigint) => [number, number];
+  readonly taffytree_new: () => number;
+  readonly taffytree_newLeaf: (
+    a: number,
+    b: number,
+  ) => [bigint, number, number];
+  readonly taffytree_newLeafWithContext: (
+    a: number,
+    b: number,
+    c: any,
+  ) => [bigint, number, number];
+  readonly taffytree_newWithChildren: (
+    a: number,
+    b: number,
+    c: number,
+    d: number,
+  ) => [bigint, number, number];
+  readonly taffytree_parent: (a: number, b: bigint) => [number, bigint];
+  readonly taffytree_printTree: (a: number, b: bigint) => void;
+  readonly taffytree_remove: (a: number, b: bigint) => [bigint, number, number];
+  readonly taffytree_removeChild: (
+    a: number,
+    b: bigint,
+    c: bigint,
+  ) => [bigint, number, number];
+  readonly taffytree_removeChildAtIndex: (
+    a: number,
+    b: bigint,
+    c: number,
+  ) => [bigint, number, number];
+  readonly taffytree_removeChildrenRange: (
+    a: number,
+    b: bigint,
+    c: number,
+    d: number,
+  ) => [number, number];
+  readonly taffytree_replaceChildAtIndex: (
+    a: number,
+    b: bigint,
+    c: number,
+    d: bigint,
+  ) => [bigint, number, number];
+  readonly taffytree_setChildren: (
+    a: number,
+    b: bigint,
+    c: number,
+    d: number,
+  ) => [number, number];
+  readonly taffytree_setNodeContext: (
+    a: number,
+    b: bigint,
+    c: any,
+  ) => [number, number];
+  readonly taffytree_setStyle: (
+    a: number,
+    b: bigint,
+    c: number,
+  ) => [number, number];
+  readonly taffytree_totalNodeCount: (a: number) => number;
+  readonly taffytree_unroundedLayout: (a: number, b: bigint) => number;
+  readonly taffytree_withCapacity: (a: number) => number;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (
+    a: number,
+    b: number,
+    c: number,
+    d: number,
+  ) => number;
+  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __externref_table_alloc: () => number;
+  readonly __wbindgen_externrefs: WebAssembly.Table;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __externref_table_dealloc: (a: number) => void;
+  readonly __externref_drop_slice: (a: number, b: number) => void;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(
+  module: { module: SyncInitInput } | SyncInitInput,
+): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init(
+  module_or_path?:
+    | { module_or_path: InitInput | Promise<InitInput> }
+    | InitInput
+    | Promise<InitInput>,
+): Promise<InitOutput>;