@ringozz/godot 0.1.0

package/gen/classes/Tree.ts

@@ -0,0 +1,521 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Control } from './Control.ts';
+import type { HorizontalAlignment } from '../global-enums.ts';
+import type { RID, Signal } from '../heap-types/index.ts';
+import type { Rect2, Vector2 } from '../value-types/index.ts';
+import type { TextDirection } from './Control.ts';
+import type { TreeItem } from './TreeItem.ts';
+
+/**
+ * A control used to show a set of internal {@link TreeItem}s in a hierarchical structure. The tree items can be selected, expanded and collapsed. The tree can have multiple columns with custom controls like {@link LineEdit}s, buttons and popups. It can be useful for structured displays and interactions.
+ * Trees are built via code, using {@link TreeItem} objects to create the structure. They have a single root, but multiple roots can be simulated with {@link hideRoot}:
+ *
+ *
+ * ```gdscript
+ *
+ * func _ready():
+ * 	var tree = Tree.new()
+ * 	var root = tree.create_item()
+ * 	tree.hide_root = true
+ * 	var child1 = tree.create_item(root)
+ * 	var child2 = tree.create_item(root)
+ * 	var subchild1 = tree.create_item(child1)
+ * 	subchild1.set_text(0, "Subchild1")
+ *
+ * ```
+ *
+ *
+ *
+ * To iterate over all the {@link TreeItem} objects in a {@link Tree} object, use {@link TreeItem.getNext} and {@link TreeItem.getFirstChild} after getting the root through {@link getRoot}. You can use {@link Object.free} on a {@link TreeItem} to remove it from the {@link Tree}.
+ * **Incremental search:** Like {@link ItemList} and {@link PopupMenu}, {@link Tree} supports searching within the list while the control is focused. Press a key that matches the first letter of an item's name to select the first item starting with the given letter. After that point, there are two ways to perform incremental search: 1) Press the same key again before the timeout duration to select the next item starting with the same letter. 2) Press letter keys that match the rest of the word before the timeout duration to match to select the item in question directly. Both of these actions will be reset to the beginning of the list if the timeout duration has passed since the last keystroke was registered. You can adjust the timeout duration by changing {@link ProjectSettings.gui/timers/incrementalSearchMaxIntervalMsec}.
+ */
+export class Tree extends Control {
+    constructor(name = 808) { super(name); }
+
+    /**
+     * Clears the tree. This removes all items.
+     * Prints an error and does not allow clearing the tree if called during mouse selection.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Creates an item in the tree and adds it as a child of `parent`, which can be either a valid {@link TreeItem} or `null`.
+     * If `parent` is `null`, the root item will be the parent, or the new item will be the root itself if the tree is empty.
+     * The new item will be the `index`-th child of parent, or it will be the last child if there are not enough siblings.
+     * Prints an error and returns `null` if called during mouse selection, or if the `parent` does not belong to this tree.
+     */
+    createItem(parent?: TreeItem /* = null */, index?: number /* = -1 */): TreeItem | null { return _C(this, 2546, parent, index) as TreeItem | null; }
+
+    /**
+     * Returns the tree's root item, or `null` if the tree is empty.
+     */
+    getRoot(): TreeItem | null { return _C(this, 6188) as TreeItem | null; }
+
+    /**
+     * Overrides the calculated minimum width of a column. It can be set to `0` to restore the default behavior. Columns that have the "Expand" flag will use their "min_width" in a similar fashion to {@link Control.sizeFlagsStretchRatio}.
+     */
+    setColumnCustomMinimumWidth(column: number, minWidth: number): void { _C(this, 10916, column, minWidth); }
+
+    /**
+     * If `true`, the column will have the "Expand" flag of {@link Control}. Columns that have the "Expand" flag will use their expand ratio in a similar fashion to {@link Control.sizeFlagsStretchRatio} (see {@link setColumnExpandRatio}).
+     */
+    setColumnExpand(column: number, expand: boolean): void { _C(this, 10917, column, expand); }
+
+    /**
+     * Sets the relative expand ratio for a column. See {@link setColumnExpand}.
+     */
+    setColumnExpandRatio(column: number, ratio: number): void { _C(this, 10918, column, ratio); }
+
+    /**
+     * Allows to enable clipping for column's content, making the content size ignored.
+     */
+    setColumnClipContent(column: number, enable: boolean): void { _C(this, 10915, column, enable); }
+
+    /**
+     * Returns `true` if the column has enabled expanding (see {@link setColumnExpand}).
+     */
+    isColumnExpanding(column: number): boolean { return _C(this, 7847, column) as boolean; }
+
+    /**
+     * Returns `true` if the column has enabled clipping (see {@link setColumnClipContent}).
+     */
+    isColumnClippingContent(column: number): boolean { return _C(this, 7846, column) as boolean; }
+
+    /**
+     * Returns the expand ratio assigned to the column.
+     */
+    getColumnExpandRatio(column: number): number { return _C(this, 4234, column) as number; }
+
+    /**
+     * Returns the column's width in pixels.
+     */
+    getColumnWidth(column: number): number { return _C(this, 4240, column) as number; }
+
+    /**
+     * Returns the internal canvas item designated for custom drawing. See {@link TreeItem.setCustomDrawCallback}.
+     * **Note:** This canvas item clears automatically on each Tree draw call.
+     */
+    getCustomDrawingCanvasItem(): RID { return _C(this, 4386) as RID; }
+
+    /**
+     * Returns the next selected {@link TreeItem} after the given one, or `null` if the end is reached.
+     * If `from` is `null`, this returns the first selected item.
+     */
+    getNextSelected(from: TreeItem): TreeItem | null { return _C(this, 5631, from) as TreeItem | null; }
+
+    /**
+     * Returns the currently focused item, or `null` if no item is focused.
+     * In {@link SELECT_ROW} and {@link SELECT_SINGLE} modes, the focused item is same as the selected item. In {@link SELECT_MULTI} mode, the focused item is the item under the focus cursor, not necessarily selected.
+     * To get the currently selected item(s), use {@link getNextSelected}.
+     */
+    getSelected(): TreeItem | null { return _C(this, 6322) as TreeItem | null; }
+
+    /**
+     * Selects the specified {@link TreeItem} and column.
+     */
+    setSelected(item: TreeItem, column: number): void { _C(this, 12688, item, column); }
+
+    /**
+     * Returns the currently focused column, or -1 if no column is focused.
+     * In {@link SELECT_SINGLE} mode, the focused column is the selected column. In {@link SELECT_ROW} mode, the focused column is always 0 if any item is selected. In {@link SELECT_MULTI} mode, the focused column is the column under the focus cursor, and there are not necessarily any column selected.
+     * To tell whether a column of an item is selected, use {@link TreeItem.isSelected}.
+     */
+    getSelectedColumn(): number { return _C(this, 6323) as number; }
+
+    /**
+     * Returns the last pressed button's index.
+     */
+    getPressedButton(): number { return _C(this, 5995) as number; }
+
+    /**
+     * Deselects all tree items (rows and columns). In {@link SELECT_MULTI} mode also removes selection cursor.
+     */
+    deselectAll(): void { _C(this, 2756); }
+
+    /**
+     * Returns the currently edited item. Can be used with {@link item_edited} to get the item that was modified.
+     *
+     *
+     * ```gdscript
+     *
+     * func _ready():
+     * 	$Tree.item_edited.connect(on_Tree_item_edited)
+     *
+     * func on_Tree_item_edited():
+     * 	print($Tree.get_edited()) # This item just got edited (e.g. checked).
+     *
+     * ```
+     */
+    getEdited(): TreeItem { return _C(this, 4600) as TreeItem; }
+
+    /**
+     * Returns the column for the currently edited item.
+     */
+    getEditedColumn(): number { return _C(this, 4601) as number; }
+
+    /**
+     * Edits the selected tree item as if it was clicked.
+     * Either the item must be set editable with {@link TreeItem.setEditable} or `forceEdit` must be `true`.
+     * Returns `true` if the item could be edited. Fails if no item is selected.
+     */
+    editSelected(forceEdit?: boolean /* = false */): boolean { return _C(this, 2997, forceEdit) as boolean; }
+
+    /**
+     * Returns the rectangle for custom popups. Helper to create custom cell controls that display a popup. See {@link TreeItem.setCellMode}.
+     */
+    getCustomPopupRect(): Rect2 { return _C(this, 4396) as Rect2; }
+
+    /**
+     * Returns the rectangle area for the specified {@link TreeItem}. If `column` is specified, only get the position and size of that column, otherwise get the rectangle containing all columns. If a button index is specified, the rectangle of that button will be returned.
+     */
+    getItemAreaRect(item: TreeItem, column?: number /* = -1 */, buttonIndex?: number /* = -1 */): Rect2 { return _C(this, 5177, item, column, buttonIndex) as Rect2; }
+
+    /**
+     * Returns the tree item at the specified position (relative to the tree origin position).
+     */
+    getItemAtPosition(position: Vector2): TreeItem { return _C(this, 5178, position) as TreeItem; }
+
+    /**
+     * Returns the column index at `position`, or -1 if no item is there.
+     */
+    getColumnAtPosition(position: Vector2): number { return _C(this, 4233, position) as number; }
+
+    /**
+     * Returns the drop section at `position`, as permitted by enabled {@link DropModeFlags}.
+     * - `-1` if the position is **above** the item. Typically used to insert as the item's previous sibling.
+     * - `0` if the position is **on** the item. Typically used to insert as the item's last child.
+     * - `1` if the position is **below** the item, when the item has no children. Typically used to insert as the item's next sibling. If the item *does* have children, this section is still reachable by hovering to the left of the item's collapse arrow, and below.
+     * - `2` if the position is **below** the item, when the item has children. Typically used to insert as the item's first child.
+     * - `-100` if the position is not over any item, or no {@link DropModeFlags} are set.
+     * See {@link DropModeFlags} for a description of each drop region. To get the item which the returned drop section refers to, use {@link getItemAtPosition}.
+     */
+    getDropSectionAtPosition(position: Vector2): number { return _C(this, 4583, position) as number; }
+
+    /**
+     * Returns the button ID at `position`, or -1 if no button is there.
+     */
+    getButtonIdAtPosition(position: Vector2): number { return _C(this, 4034, position) as number; }
+
+    /**
+     * Makes the currently focused cell visible.
+     * This will scroll the tree if necessary. In {@link SELECT_ROW} mode, this will not do horizontal scrolling, as all the cells in the selected row is focused logically.
+     * **Note:** Despite the name of this method, the focus cursor itself is only visible in {@link SELECT_MULTI} mode.
+     */
+    ensureCursorIsVisible(): void { _C(this, 3109); }
+
+    /**
+     * Sets the title of a column.
+     */
+    setColumnTitle(column: number, title: string): void { _C(this, 10919, column, title); }
+
+    /**
+     * Returns the column's title.
+     */
+    getColumnTitle(column: number): string { return _C(this, 4235, column) as string; }
+
+    /**
+     * Sets the column title's tooltip text.
+     */
+    setColumnTitleTooltipText(column: number, tooltipText: string): void { _C(this, 10923, column, tooltipText); }
+
+    /**
+     * Returns the column title's tooltip text.
+     */
+    getColumnTitleTooltipText(column: number): string { return _C(this, 4239, column) as string; }
+
+    /**
+     * Sets the column title alignment. Note that {@link HORIZONTAL_ALIGNMENT_FILL} is not supported for column titles.
+     */
+    setColumnTitleAlignment(column: number, titleAlignment: HorizontalAlignment): void { _C(this, 10920, column, titleAlignment); }
+
+    /**
+     * Returns the column title alignment.
+     */
+    getColumnTitleAlignment(column: number): HorizontalAlignment { return _C(this, 4236, column) as HorizontalAlignment; }
+
+    /**
+     * Sets column title base writing direction.
+     */
+    setColumnTitleDirection(column: number, direction: TextDirection): void { _C(this, 10921, column, direction); }
+
+    /**
+     * Returns column title base writing direction.
+     */
+    getColumnTitleDirection(column: number): TextDirection { return _C(this, 4237, column) as TextDirection; }
+
+    /**
+     * Sets the language code of the given `column`'s title to `language`. This is used for line-breaking and text shaping algorithms. If `language` is empty, the current locale is used.
+     */
+    setColumnTitleLanguage(column: number, language: string): void { _C(this, 10922, column, language); }
+
+    /**
+     * Returns column title language code.
+     */
+    getColumnTitleLanguage(column: number): string { return _C(this, 4238, column) as string; }
+
+    /**
+     * Returns the current scrolling position.
+     */
+    getScroll(): Vector2 { return _C(this, 6277) as Vector2; }
+
+    /**
+     * Causes the {@link Tree} to jump to the specified {@link TreeItem}.
+     */
+    scrollToItem(item: TreeItem, centerOnItem?: boolean /* = false */): void { _C(this, 10295, item, centerOnItem); }
+
+    /**
+     * The number of columns.
+     * Prints an error and does not allow setting the columns during mouse selection.
+     */
+    get columns(): number { return _C(this, 4241) as number; }
+    set columns(v: number) { _C(this, 10925, v); }
+
+    /**
+     * If `true`, column titles are visible.
+     */
+    get columnTitlesVisible(): boolean { return _C(this, 1542) as boolean; }
+    set columnTitlesVisible(v: boolean) { _C(this, 10924, v); }
+
+    /**
+     * If `true`, the currently selected cell may be selected again.
+     */
+    get allowReselect(): boolean { return _C(this, 3719) as boolean; }
+    set allowReselect(v: boolean) { _C(this, 10457, v); }
+
+    /**
+     * If `true`, a right mouse button click can select items.
+     */
+    get allowRmbSelect(): boolean { return _C(this, 3720) as boolean; }
+    set allowRmbSelect(v: boolean) { _C(this, 10458, v); }
+
+    /**
+     * If `true`, allows navigating the {@link Tree} with letter keys through incremental search.
+     */
+    get allowSearch(): boolean { return _C(this, 3721) as boolean; }
+    set allowSearch(v: boolean) { _C(this, 10459, v); }
+
+    /**
+     * If `true`, the folding arrow is hidden.
+     */
+    get hideFolding(): boolean { return _C(this, 7965) as boolean; }
+    set hideFolding(v: boolean) { _C(this, 11623, v); }
+
+    /**
+     * If `true`, recursive folding is enabled for this {@link Tree}. Holding down `Shift` while clicking the fold arrow or using `ui_right`/`ui_left` shortcuts collapses or uncollapses the {@link TreeItem} and all its descendants.
+     */
+    get enableRecursiveFolding(): boolean { return _C(this, 8233) as boolean; }
+    set enableRecursiveFolding(v: boolean) { _C(this, 11281, v); }
+
+    /**
+     * If `true`, tree items will unfold when hovered over during a drag-and-drop. The delay for when this happens is dictated by {@link dragging_unfold_wait_msec}.
+     */
+    get enableDragUnfolding(): boolean { return _C(this, 7897) as boolean; }
+    set enableDragUnfolding(v: boolean) { _C(this, 11275, v); }
+
+    /**
+     * If `true`, the tree's root is hidden.
+     */
+    get hideRoot(): boolean { return _C(this, 8250) as boolean; }
+    set hideRoot(v: boolean) { _C(this, 11628, v); }
+
+    /**
+     * The drop mode as an OR combination of flags. See {@link DropModeFlags} constants. Once dropping is done, reverts to {@link DROP_MODE_DISABLED}. Setting this during {@link Control.CanDropData} is recommended.
+     * This controls the drop sections, i.e. the decision and drawing of possible drop locations based on the mouse position.
+     */
+    get dropModeFlags(): number { return _C(this, 4582) as number; }
+    set dropModeFlags(v: number) { _C(this, 11199, v); }
+
+    /**
+     * Allows single or multiple selection. See the {@link SelectMode} constants.
+     */
+    get selectMode(): SelectMode { return _C(this, 6319) as SelectMode; }
+    set selectMode(v: SelectMode) { _C(this, 12685, v); }
+
+    /**
+     * If `true`, tree items with no tooltip assigned display their text as their tooltip. See also {@link TreeItem.getTooltipText} and {@link TreeItem.getButtonTooltipText}.
+     */
+    get autoTooltip(): boolean { return _C(this, 7775) as boolean; }
+    set autoTooltip(v: boolean) { _C(this, 10580, v); }
+
+    /**
+     * If `true`, enables horizontal scrolling.
+     */
+    get scrollHorizontalEnabled(): boolean { return _C(this, 7984) as boolean; }
+    set scrollHorizontalEnabled(v: boolean) { _C(this, 11588, v); }
+
+    /**
+     * If `true`, enables vertical scrolling.
+     */
+    get scrollVerticalEnabled(): boolean { return _C(this, 8431) as boolean; }
+    set scrollVerticalEnabled(v: boolean) { _C(this, 13265, v); }
+
+    /**
+     * The way which scroll hints (indicators that show that the content can still be scrolled in a certain direction) will be shown.
+     */
+    get scrollHintMode(): ScrollHintMode { return _C(this, 6280) as ScrollHintMode; }
+    set scrollHintMode(v: ScrollHintMode) { _C(this, 12638, v); }
+
+    /**
+     * If `true`, the scroll hint texture will be tiled instead of stretched. See {@link scrollHintMode}.
+     */
+    get tileScrollHint(): boolean { return _C(this, 8275) as boolean; }
+    set tileScrollHint(v: boolean) { _C(this, 13074, v); }
+
+    /**
+     * Emitted when an item is selected.
+     */
+    get itemSelected(): Signal<() => void> { return _G(this, 8469) as Signal<() => void>; }
+    set itemSelected(v: (() => void) | null) { _G(this, 8469, v); }
+
+    /**
+     * Emitted when a cell is selected.
+     */
+    get cellSelected(): Signal<() => void> { return _G(this, 2166) as Signal<() => void>; }
+    set cellSelected(v: (() => void) | null) { _G(this, 2166, v); }
+
+    /**
+     * Emitted instead of {@link item_selected} if {@link selectMode} is set to {@link SELECT_MULTI}.
+     */
+    get multiSelected(): Signal<(item: TreeItem, column: number, selected: boolean) => void> { return _G(this, 9011) as Signal<(item: TreeItem, column: number, selected: boolean) => void>; }
+    set multiSelected(v: ((item: TreeItem, column: number, selected: boolean) => void) | null) { _G(this, 9011, v); }
+
+    /**
+     * Emitted when an item is selected with a mouse button.
+     */
+    get itemMouseSelected(): Signal<(mousePosition: Vector2, mouseButtonIndex: number) => void> { return _G(this, 8467) as Signal<(mousePosition: Vector2, mouseButtonIndex: number) => void>; }
+    set itemMouseSelected(v: ((mousePosition: Vector2, mouseButtonIndex: number) => void) | null) { _G(this, 8467, v); }
+
+    /**
+     * Emitted when a mouse button is clicked in the empty space of the tree.
+     */
+    get emptyClicked(): Signal<(clickPosition: Vector2, mouseButtonIndex: number) => void> { return _G(this, 3051) as Signal<(clickPosition: Vector2, mouseButtonIndex: number) => void>; }
+    set emptyClicked(v: ((clickPosition: Vector2, mouseButtonIndex: number) => void) | null) { _G(this, 3051, v); }
+
+    /**
+     * Emitted when an item is edited.
+     */
+    get itemEdited(): Signal<() => void> { return _G(this, 8464) as Signal<() => void>; }
+    set itemEdited(v: (() => void) | null) { _G(this, 8464, v); }
+
+    /**
+     * Emitted when an item with {@link TreeItem.CELL_MODE_CUSTOM} is clicked with a mouse button.
+     */
+    get customItemClicked(): Signal<(mouseButtonIndex: number) => void> { return _G(this, 2625) as Signal<(mouseButtonIndex: number) => void>; }
+    set customItemClicked(v: ((mouseButtonIndex: number) => void) | null) { _G(this, 2625, v); }
+
+    /**
+     * Emitted when an item's icon is double-clicked. For a signal that emits when any part of the item is double-clicked, see {@link item_activated}.
+     */
+    get itemIconDoubleClicked(): Signal<() => void> { return _G(this, 8466) as Signal<() => void>; }
+    set itemIconDoubleClicked(v: (() => void) | null) { _G(this, 8466, v); }
+
+    /**
+     * Emitted when an item is expanded or collapsed by clicking on the folding arrow or through code.
+     * **Note:** Despite its name, this signal is also emitted when an item is expanded.
+     */
+    get itemCollapsed(): Signal<(item: TreeItem) => void> { return _G(this, 8462) as Signal<(item: TreeItem) => void>; }
+    set itemCollapsed(v: ((item: TreeItem) => void) | null) { _G(this, 8462, v); }
+
+    /**
+     * Emitted when {@link TreeItem.propagateCheck} is called. Connect to this signal to process the items that are affected when {@link TreeItem.propagateCheck} is invoked. The order that the items affected will be processed is as follows: the item that invoked the method, children of that item, and finally parents of that item.
+     */
+    get checkPropagatedToItem(): Signal<(item: TreeItem, column: number) => void> { return _G(this, 2194) as Signal<(item: TreeItem, column: number) => void>; }
+    set checkPropagatedToItem(v: ((item: TreeItem, column: number) => void) | null) { _G(this, 2194, v); }
+
+    /**
+     * Emitted when a button on the tree was pressed (see {@link TreeItem.addButton}).
+     */
+    get buttonClicked(): Signal<(item: TreeItem, column: number, id: number, mouseButtonIndex: number) => void> { return _G(this, 1942) as Signal<(item: TreeItem, column: number, id: number, mouseButtonIndex: number) => void>; }
+    set buttonClicked(v: ((item: TreeItem, column: number, id: number, mouseButtonIndex: number) => void) | null) { _G(this, 1942, v); }
+
+    /**
+     * Emitted when a cell with the {@link TreeItem.CELL_MODE_CUSTOM} is clicked to be edited.
+     */
+    get customPopupEdited(): Signal<(arrowClicked: boolean) => void> { return _G(this, 2629) as Signal<(arrowClicked: boolean) => void>; }
+    set customPopupEdited(v: ((arrowClicked: boolean) => void) | null) { _G(this, 2629, v); }
+
+    /**
+     * Emitted when an item is double-clicked, or selected with a `ui_accept` input event (e.g. using `Enter` or `Space` on the keyboard).
+     */
+    get itemActivated(): Signal<() => void> { return _G(this, 8460) as Signal<() => void>; }
+    set itemActivated(v: (() => void) | null) { _G(this, 8460, v); }
+
+    /**
+     * Emitted when a column's title is clicked with either {@link MOUSE_BUTTON_LEFT} or {@link MOUSE_BUTTON_RIGHT}.
+     */
+    get columnTitleClicked(): Signal<(column: number, mouseButtonIndex: number) => void> { return _G(this, 2378) as Signal<(column: number, mouseButtonIndex: number) => void>; }
+    set columnTitleClicked(v: ((column: number, mouseButtonIndex: number) => void) | null) { _G(this, 2378, v); }
+
+    /**
+     * Emitted when a left mouse button click does not select any item.
+     */
+    get nothingSelected(): Signal<() => void> { return _G(this, 9104) as Signal<() => void>; }
+    set nothingSelected(v: (() => void) | null) { _G(this, 9104, v); }
+
+    static readonly name = _R(808, Tree);
+}
+
+export const SelectMode = {
+    /**
+     * Allows selection of a single cell at a time. From the perspective of items, only a single item is allowed to be selected. And there is only one column selected in the selected item.
+     * The focus cursor is always hidden in this mode, but it is positioned at the current selection, making the currently selected item the currently focused item.
+     */
+    SELECT_SINGLE: 0,
+    /**
+     * Allows selection of a single row at a time. From the perspective of items, only a single items is allowed to be selected. And all the columns are selected in the selected item.
+     * The focus cursor is always hidden in this mode, but it is positioned at the first column of the current selection, making the currently selected item the currently focused item.
+     */
+    SELECT_ROW: 1,
+    /**
+     * Allows selection of multiple cells at the same time. From the perspective of items, multiple items are allowed to be selected. And there can be multiple columns selected in each selected item.
+     * The focus cursor is visible in this mode, the item or column under the cursor is not necessarily selected.
+     */
+    SELECT_MULTI: 2,
+} as const;
+
+export type SelectMode = (typeof SelectMode)[keyof typeof SelectMode];
+
+export const DropModeFlags = {
+    /**
+     * Disables all drop sections.
+     * **Note:** This is the default flag, it has no effect when combined with other flags.
+     */
+    DROP_MODE_DISABLED: 0,
+    /**
+     * Enables the "on item" drop section. This drop section covers the entire item.
+     * When combined with {@link DROP_MODE_INBETWEEN}, this drop section halves in height and stays centered vertically.
+     */
+    DROP_MODE_ON_ITEM: 1,
+    /**
+     * Enables "above item" and "below item" drop sections. The "above item" drop section covers the top half of the item, while the "below item" drop section covers the bottom half, and extends downward to the left of any children.
+     * When combined with {@link DROP_MODE_ON_ITEM}, these drop sections halve in height and stay at the top and bottom respectively.
+     */
+    DROP_MODE_INBETWEEN: 2,
+} as const;
+
+export type DropModeFlags = (typeof DropModeFlags)[keyof typeof DropModeFlags];
+
+export const ScrollHintMode = {
+    /**
+     * Scroll hints will never be shown.
+     */
+    SCROLL_HINT_MODE_DISABLED: 0,
+    /**
+     * Scroll hints will be shown at the top and bottom.
+     */
+    SCROLL_HINT_MODE_BOTH: 1,
+    /**
+     * Only the top scroll hint will be shown.
+     */
+    SCROLL_HINT_MODE_TOP: 2,
+    /**
+     * Only the bottom scroll hint will be shown.
+     */
+    SCROLL_HINT_MODE_BOTTOM: 3,
+} as const;
+
+export type ScrollHintMode = (typeof ScrollHintMode)[keyof typeof ScrollHintMode];
+