import type { NobjcObject } from "objc-js";
import type { _NSTableColumn } from "./NSTableColumn.js";
import type { _NSTableView } from "./NSTableView.js";
import type { _NSIndexSet } from "../Foundation/NSIndexSet.js";
import type { CGRect } from "../structs/CGRect.js";
import type { NSTableViewAnimationOptions } from "./NSTableViewAnimationOptions.js";
import type { NSUserInterfaceLayoutDirection } from "./NSUserInterfaceLayoutDirection.js";
export declare class _NSOutlineView extends _NSTableView {
    static alloc(): _NSOutlineView;
    static new(): _NSOutlineView;
    init(): _NSOutlineView;
    /**
     * Returns YES if 'item' is expandable and can contain other items. May call out to the delegate/datasource, if required.
     */
    isExpandable$(item: NobjcObject | null): boolean;
    /**
     * Returns the number of children for a given parent item. This is mostly useful for static outline views where the data was encoded at design time; however, it will work for both static and non-static outline views. This may call out to the datasource, if required.
     */
    numberOfChildrenOfItem$(item: NobjcObject | null): number;
    /**
     * Returns the child item for a given parent item. This is mostly useful for static outline views where the data was encoded at design time, however, it will work for both static and non-static outline views. This may call out to the datasource, if required.
     */
    child$ofItem$(index: number, item: NobjcObject | null): NobjcObject | null;
    /**
     * Expands 'item', if not already expanded, and all children if 'expandChildren' is YES. On 10.5 and higher, passing 'nil' for 'item' will expand each item under the root.
     */
    expandItem$expandChildren$(item: NobjcObject | null, expandChildren: boolean): void;
    /** Calls expandItem:expandChildren with 'expandChildren == NO' */
    expandItem$(item: NobjcObject | null): void;
    /**
     * Collapses 'item' and all children if 'collapseChildren' is YES. On 10.5 and higher, passing 'nil' for 'item' will collapse each item under the root.
     */
    collapseItem$collapseChildren$(item: NobjcObject | null, collapseChildren: boolean): void;
    /** Calls collapseItem:collapseChildren with 'collapseChildren == NO' */
    collapseItem$(item: NobjcObject | null): void;
    /**
     * Reloads 'item' and all children if 'reloadChildren' is YES. On 10.5 and higher, passing 'nil' for 'item' will reload everything under the root item.
     */
    reloadItem$reloadChildren$(item: NobjcObject | null, reloadChildren: boolean): void;
    /** Calls reloadItem:reloadChildren with 'reloadChildren == NO' */
    reloadItem$(item: NobjcObject | null): void;
    /** Returns the parent for 'item', or nil, if the parent is the root. */
    parentForItem$(item: NobjcObject | null): NobjcObject | null;
    /**
     * Returns the child index of 'item' within its parent. The performance of this method is O(1) at best and O(n) at worst.
     */
    childIndexForItem$(item: NobjcObject): number;
    /** Item/Row translation */
    itemAtRow$(row: number): NobjcObject | null;
    rowForItem$(item: NobjcObject | null): number;
    /** Indentation */
    levelForItem$(item: NobjcObject | null): number;
    levelForRow$(row: number): number;
    isItemExpanded$(item: NobjcObject | null): boolean;
    /**
     * Returns the frame of the outline cell for a particular row, considering the current indentation and indentationMarkerFollowsCell value. If 'row' is not an expandable row, it will return NSZeroRect. This method can be overridden by subclassers to return a custom frame for the outline button cell. If an empty rect is returned, no outline cell will be drawn for that row.
     */
    frameOfOutlineCellAtRow$(row: number): CGRect;
    /**
     * To be used from validateDrop: in order to "re-target" the proposed drop. To specify a drop on an item I, one would specify item=I, and index=NSOutlineViewDropOnItemIndex. To specify a drop between child 2 and 3 of an item I, on would specify item=I, and index=3 (children are zero-base indexed). To specify a drop on an un-expandable item I, one would specify item=I, and index=NSOutlineViewDropOnItemIndex.
     */
    setDropItem$dropChildIndex$(item: NobjcObject | null, index: number): void;
    /**
     * This method returns YES to indicate that auto expanded items should return to their original collapsed state. Override this method to provide custom behavior. 'deposited' tells wether or not the drop terminated due to a successful drop (as indicated by the return value from acceptDrop:). Note that exiting the view will be treated the same as a failed drop.
     */
    shouldCollapseAutoExpandedItemsForDeposited$(deposited: boolean): boolean;
    /**
     * This method parallels TableView's -insertRowIndexes:withAnimation:, and is used in a way similar to NSMutableArray's -insertObjects:atIndexes: This method inserts a new item at 'indexes' in 'parent'. 'parent' can be nil to insert items into the root of the OutlineView. The operation will not do anything if 'parent' is not expanded. The actual item values are determined by the dataSource methods -outlineView:child:ofItem: (note that this will only be called after an -endUpdates happens to ensure dataSource integrity). Calling this method multiple times within the same beginUpdates/endUpdates block is allowed; new insertions will move previously inserted new items, just like modifying an array. Inserting an index beyond what is available will throw an exception. The "Cell Based TableView" must first call -beginUpdates before calling this method. This method can also be used when "usesStaticContents=YES".
     */
    insertItemsAtIndexes$inParent$withAnimation$(indexes: _NSIndexSet, parent: NobjcObject | null, animationOptions: NSTableViewAnimationOptions): void;
    /**
     * This method parallels TableView's -removeRowsAtIndexes:withAnimation:, and is used similar to NSMutableArray's -removeObjectsAtIndexes:. The items at the given indexes will be removed from the parent. The operation will not do anything if 'parent' is not expanded. If one of the children items is expanded, then all of its children rows will also be removed. Calling this method multiple times within the same beginUpdates/endUpdates block is allowed; changes work just like modifying an array. Deleting an index beyond what is available will throw an exception. The "Cell Based TableView" must first call -beginUpdates before calling this method. This method can also be used when "usesStaticContents=YES".
     */
    removeItemsAtIndexes$inParent$withAnimation$(indexes: _NSIndexSet, parent: NobjcObject | null, animationOptions: NSTableViewAnimationOptions): void;
    /**
     * This method parallels TableView's -moveRowAtIndex:toIndex:. The item located at 'fromIndex' is moved from the existing 'oldParent' to the given index in 'newParent'. 'newParent' can be the same as 'oldParent' to reorder an item within the same parent. This method can be called multiple times within the same beginUpdates/endUpdates block. Moving from an invalid index, or to an invalid index will throw an exception. The "Cell Based TableView" must first call -beginUpdates before calling this method. This method can also be used when "usesStaticContents=YES".
     */
    moveItemAtIndex$inParent$toIndex$inParent$(fromIndex: number, oldParent: NobjcObject | null, toIndex: number, newParent: NobjcObject | null): void;
    /**
     * The 'outlineTableColumn' is the column that displays data in a hierarchical fashion, indented one identationlevel per level, decorated with indentation marker (disclosure triangle) on rows that are expandable. A nil 'outlineTableColumn' is silently ignored. On 10.5 and higher, this value is saved in encodeWithCoder: and restored in initWithCoder:.
     */
    outlineTableColumn(): _NSTableColumn | null;
    setOutlineTableColumn$(value: _NSTableColumn | null): void;
    /**
     * Controls the amount of indentation per level. Negative values are ignored, and only integral values are accepted. The default value is 16.0. An indentationPerLevel of 0 can be used to eliminate all indentation and make an NSOutlineView appear more like an NSTableView.
     */
    indentationPerLevel(): number;
    setIndentationPerLevel$(value: number): void;
    /**
     * The indentation marker is the visual indicator that shows an item is expandable (i.e. disclosure triangle). The default value is YES.
     */
    indentationMarkerFollowsCell(): boolean;
    setIndentationMarkerFollowsCell$(value: boolean): void;
    /**
     * If autoresizesOutlineColumn is YES, then the outlineTableColumn will automatically resize when there is a new expanded child at a particular depth level. The default value is YES.
     */
    autoresizesOutlineColumn(): boolean;
    setAutoresizesOutlineColumn$(value: boolean): void;
    /**
     * Persistence. The value for autosaveExpandedItems is saved out in the nib file on Mac OS 10.5 or higher. The default value is NO. Calling setAutosaveExpandedItems:YES requires you to implement outlineView:itemForPersistentObject: and outlineView:persistentObjectForItem:.
     */
    autosaveExpandedItems(): boolean;
    setAutosaveExpandedItems$(value: boolean): void;
    /**
     * Get and set the user interface layout direction. When set to NSUserInterfaceLayoutDirectionRightToLeft, the Outline View will show the disclosure triangle to the right of the cell instead of the left. This method is available for NSOutlineView on 10.7 and higher.
     */
    userInterfaceLayoutDirection(): NSUserInterfaceLayoutDirection;
    setUserInterfaceLayoutDirection$(value: NSUserInterfaceLayoutDirection): void;
    /**
     * When YES, the NSOutlineView will retain and release the objects returned to it from the dataSource (outlineView:child:ofItem:). When NO, it only treats the objects as opaque items and assume the client has a retain on them. The default value is YES for applications linked on 10.12 and later, and NO for previous applications. This value is not encoded in the nib, and must be explicitly set to NO in code if one requires the legacy behavior and is linking on 10.12 and later. In general, this is required if the items themselves create a retain cycle.
     */
    stronglyReferencesItems(): boolean;
    setStronglyReferencesItems$(value: boolean): void;
}
