import '../../../../assert/js/assert.js';
import '../../../../globals.js';
import Orientation from '../../../../phet-core/js/Orientation.js';
import StrictOmit from '../../../../phet-core/js/types/StrictOmit.js';
import { GridConstraint, GridConstraintOptions, HorizontalLayoutAlign, LayoutNode, LayoutNodeOptions, Node, VerticalLayoutAlign } from '../../imports.js';
type LineArray = (Node | null)[];
type LineArrays = LineArray[];
type GridConstraintExcludedOptions = 'excludeInvisible' | 'preferredWidthProperty' | 'preferredHeightProperty' | 'minimumWidthProperty' | 'minimumHeightProperty' | 'layoutOriginProperty';
type SelfOptions = {
    resize?: boolean;
    rows?: LineArrays;
    columns?: LineArrays;
    autoRows?: number | null;
    autoColumns?: number | null;
} & StrictOmit<GridConstraintOptions, GridConstraintExcludedOptions>;
export type GridBoxOptions = SelfOptions & LayoutNodeOptions;
export default class GridBox extends LayoutNode<GridConstraint> {
    private readonly _cellMap;
    private _autoRows;
    private _autoColumns;
    private _autoLockCount;
    private readonly onChildInserted;
    private readonly onChildRemoved;
    private readonly onChildVisibilityToggled;
    constructor(providedOptions?: GridBoxOptions);
    /**
     * Sets the children of the GridBox and adjusts them to be positioned in certain cells. It takes a 2-dimensional array
     * of Node|null (where null is a placeholder that does nothing).
     *
     * For each cell, the first index into the array will be taken as the cell position in the provided orientation. The
     * second index into the array will be taken as the cell position in the OPPOSITE orientation.
     *
     * See GridBox.rows or GridBox.columns for usages and more documentation.
     */
    setLines(orientation: Orientation, lineArrays: LineArrays): void;
    /**
     * Returns the children of the GridBox in a 2-dimensional array of Node|null (where null is a placeholder that does
     * nothing).
     *
     * For each cell, the first index into the array will be taken as the cell position in the provided orientation. The
     * second index into the array will be taken as the cell position in the OPPOSITE orientation.
     *
     * See GridBox.rows or GridBox.columns for usages
     */
    getLines(orientation: Orientation): LineArrays;
    /**
     * Sets the children of the GridBox by specifying a two-dimensional array of Nodes (or null values as spacers).
     * The inner arrays will be the rows of the grid.
     * Mutates layoutOptions of the provided Nodes. See setLines() for more documentation.
     */
    set rows(lineArrays: LineArrays);
    /**
     * Returns a two-dimensional array of the child Nodes (with null as a spacer) where the inner arrays are the rows.
     */
    get rows(): LineArrays;
    /**
     * Sets the children of the GridBox by specifying a two-dimensional array of Nodes (or null values as spacers).
     * The inner arrays will be the columns of the grid.
     * * Mutates layoutOptions of the provided Nodes. See setLines() for more documentation.
     */
    set columns(lineArrays: LineArrays);
    /**
     * Returns a two-dimensional array of the child Nodes (with null as a spacer) where the inner arrays are the columns.
     */
    get columns(): LineArrays;
    /**
     * Returns the Node at a specific row/column intersection (or null if there are none)
     */
    getNodeAt(row: number, column: number): Node | null;
    /**
     * Returns the row index of a child Node (or if it spans multiple rows, the first row)
     */
    getRowOfNode(node: Node): number;
    /**
     * Returns the column index of a child Node (or if it spans multiple columns, the first row)
     */
    getColumnOfNode(node: Node): number;
    /**
     * Returns all the Nodes in a given row (by index)
     */
    getNodesInRow(index: number): Node[];
    /**
     * Returns all the Nodes in a given column (by index)
     */
    getNodesInColumn(index: number): Node[];
    /**
     * Adds an array of child Nodes (with null allowed as empty spacers) at the bottom of all existing rows.
     */
    addRow(row: LineArray): this;
    /**
     * Adds an array of child Nodes (with null allowed as empty spacers) at the right of all existing columns.
     */
    addColumn(column: LineArray): this;
    /**
     * Inserts a row of child Nodes at a given row index (see addRow for more information)
     */
    insertRow(index: number, row: LineArray): this;
    /**
     * Inserts a column of child Nodes at a given column index (see addColumn for more information)
     */
    insertColumn(index: number, column: LineArray): this;
    /**
     * Removes all child Nodes in a given row
     */
    removeRow(index: number): this;
    /**
     * Removes all child Nodes in a given column
     */
    removeColumn(index: number): this;
    set autoRows(value: number | null);
    get autoRows(): number | null;
    set autoColumns(value: number | null);
    get autoColumns(): number | null;
    private updateAutoLines;
    private updateAutoRows;
    private updateAutoColumns;
    private updateAllAutoLines;
    setChildren(children: Node[]): this;
    /**
     * Called when a child is inserted.
     */
    private onGridBoxChildInserted;
    /**
     * Called when a child is removed.
     *
     * NOTE: This is NOT called on disposal. Any additional cleanup (to prevent memory leaks) should be included in the
     * dispose() function
     */
    private onGridBoxChildRemoved;
    mutate(options?: GridBoxOptions): this;
    get spacing(): number | number[];
    set spacing(value: number | number[]);
    get xSpacing(): number | number[];
    set xSpacing(value: number | number[]);
    get ySpacing(): number | number[];
    set ySpacing(value: number | number[]);
    get xAlign(): HorizontalLayoutAlign;
    set xAlign(value: HorizontalLayoutAlign);
    get yAlign(): VerticalLayoutAlign;
    set yAlign(value: VerticalLayoutAlign);
    get grow(): number;
    set grow(value: number);
    get xGrow(): number;
    set xGrow(value: number);
    get yGrow(): number;
    set yGrow(value: number);
    get stretch(): boolean;
    set stretch(value: boolean);
    get xStretch(): boolean;
    set xStretch(value: boolean);
    get yStretch(): boolean;
    set yStretch(value: boolean);
    get margin(): number;
    set margin(value: number);
    get xMargin(): number;
    set xMargin(value: number);
    get yMargin(): number;
    set yMargin(value: number);
    get leftMargin(): number;
    set leftMargin(value: number);
    get rightMargin(): number;
    set rightMargin(value: number);
    get topMargin(): number;
    set topMargin(value: number);
    get bottomMargin(): number;
    set bottomMargin(value: number);
    get minContentWidth(): number | null;
    set minContentWidth(value: number | null);
    get minContentHeight(): number | null;
    set minContentHeight(value: number | null);
    get maxContentWidth(): number | null;
    set maxContentWidth(value: number | null);
    get maxContentHeight(): number | null;
    set maxContentHeight(value: number | null);
    setExcludeInvisibleChildrenFromBounds(excludeInvisibleChildrenFromBounds: boolean): void;
    dispose(): void;
    getHelperNode(): Node;
}
export {};
//# sourceMappingURL=GridBox.d.ts.map