appui-layout-react.api.md

API Report File for "@itwin/appui-layout-react"

Do not edit this file. It is a report generated by API Extractor.

import { CommonProps } from '@itwin/core-react';
import * as CSS from 'csstype';
import { Draft } from 'immer';
import { IconSpec } from '@itwin/core-react';
import { Interaction } from 'scheduler/tracing';
import { NoChildrenProps } from '@itwin/core-react';
import { Omit } from '@itwin/core-react';
import { OmitChildrenProp } from '@itwin/core-react';
import { Point } from '@itwin/core-react';
import { PointProps } from '@itwin/appui-abstract';
import { PopupProps } from '@itwin/core-react';
import * as PropTypes from 'prop-types';
import * as React from 'react';
import { Rectangle } from '@itwin/core-react';
import { RectangleProps } from '@itwin/core-react';
import { SizeProps } from '@itwin/core-react';

// @internal (undocumented)
export const ActiveTabIdContext: React.Context<string>;

// @internal (undocumented)
export function addFloatingWidget(state: NineZoneState, id: FloatingWidgetState["id"], tabs: WidgetState["tabs"], floatingWidgetArgs?: Partial<FloatingWidgetState>, widgetArgs?: Partial<WidgetState>): NineZoneState;

// @internal (undocumented)
export function addPanelWidget(state: NineZoneState, side: PanelSide, id: WidgetState["id"], tabs: WidgetState["tabs"], widgetArgs?: Partial<WidgetState>): NineZoneState;

// @internal (undocumented)
export function addPopoutWidget(state: NineZoneState, id: PopoutWidgetState["id"], tabs: WidgetState["tabs"], popoutWidgetArgs?: Partial<PopoutWidgetState>, widgetArgs?: Partial<WidgetState>): NineZoneState;

// @internal (undocumented)
export function addTab(state: NineZoneState, id: TabState["id"], tabArgs?: Partial<TabState>): NineZoneState;

// @internal
export function addWidgetTabToFloatingPanel(state: NineZoneState, floatingWidgetId: string, widgetTabId: string, home: FloatingWidgetHomeState, preferredSize?: SizeProps, preferredPosition?: PointProps, userSized?: boolean, isFloatingStateWindowResizable?: boolean): NineZoneState;

// @internal
export class AppButton extends React.PureComponent<AppButtonProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface AppButtonProps extends OmitChildrenProp<ToolbarIconProps>, NoChildrenProps {
    mouseProximity?: number;
    small?: boolean;
}

// @internal
export const AppContent: React.NamedExoticComponent<object>;

// @internal
export class BackArrow extends React.PureComponent<BackArrowProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface BackArrowProps extends CommonProps, NoChildrenProps {
    onClick?: () => void;
    onPointerUp?: () => void;
}

// @internal
export class BackButton extends React.PureComponent<BackButtonProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface BackButtonProps extends OmitChildrenProp<ToolbarIconProps>, NoChildrenProps {
}

// @internal
export class Backstage extends React.PureComponent<BackstageProps> {
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static readonly defaultProps: BackstageDefaultProps;
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export type BackstageDefaultProps = Pick<BackstageProps, "showOverlay">;

// @internal
export class BackstageItem extends React.PureComponent<BackstageItemProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface BackstageItemProps extends CommonProps {
    badge?: React.ReactNode;
    children?: string;
    icon?: React.ReactNode;
    isActive?: boolean;
    isDisabled?: boolean;
    onClick?: () => void;
    safeAreaInsets?: SafeAreaInsets;
    subtitle?: string;
}

// @internal
export interface BackstageProps extends CommonProps {
    children?: React.ReactNode;
    footer?: React.ReactNode;
    header?: React.ReactNode;
    isOpen?: boolean;
    onClose?: () => void;
    safeAreaInsets?: SafeAreaInsets;
    showOverlay: boolean;
}

// @internal
export class BackstageSeparator extends React.PureComponent<CommonProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export class BackTarget extends React.PureComponent<BackTargetProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface BackTargetProps extends MergeTargetProps {
    zoneIndex: WidgetZoneId;
}

// @internal (undocumented)
export type BottomPanelSide = "bottom";

// @internal
export class Cell implements CellProps {
    constructor(row: number, col: number);
    // (undocumented)
    readonly col: number;
    static create(props: CellProps): Cell;
    // (undocumented)
    equals(other: CellProps): boolean;
    // (undocumented)
    getAlignedCellsTo(other: CellProps): CellProps[];
    // (undocumented)
    getHorizontallyAlignedCellsTo(other: CellProps): CellProps[];
    // (undocumented)
    getVerticallyAlignedCellsTo(other: CellProps): CellProps[];
    // (undocumented)
    isBetween(cell1: CellProps, cell2: CellProps): boolean;
    // (undocumented)
    isColumnAlignedWith(other: CellProps): boolean;
    // (undocumented)
    isHorizontallyBetween(cell1: CellProps, cell2: CellProps): boolean;
    // (undocumented)
    isRowAlignedWith(other: CellProps): boolean;
    // (undocumented)
    isVerticallyBetween(cell1: CellProps, cell2: CellProps): boolean;
    // (undocumented)
    readonly row: number;
}

// @internal
export interface CellProps {
    readonly col: number;
    readonly row: number;
}

// @internal
export const CenterContent: React.NamedExoticComponent<object>;

// @internal (undocumented)
export const CenterContentNodeContext: React.Context<React.ReactNode>;

// @internal
export class Columns extends React.PureComponent<ColumnsProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface ColumnsProps extends CommonProps {
    children?: React.ReactNode;
}

// @alpha @deprecated
export const contain: (componentBounds: RectangleProps, containerBounds: RectangleProps) => RectangleProps;

// @alpha @deprecated
export const containHorizontally: (componentBounds: RectangleProps, containerBounds: RectangleProps) => RectangleProps;

// @alpha @deprecated
export const containVertically: (componentBounds: RectangleProps, containerBounds: RectangleProps) => RectangleProps;

// @internal (undocumented)
export const ContentNodeContext: React.Context<React.ReactNode>;

// @internal
export type ContentZoneId = 5;

// @internal
export function convertAllPopupWidgetContainersToFloating(state: NineZoneState): NineZoneState;

// @internal (undocumented)
export function convertFloatingWidgetContainerToPopout(state: NineZoneState, widgetContainerId: string): NineZoneState;

// @internal (undocumented)
export function convertPopoutWidgetContainerToFloating(state: NineZoneState, widgetContainerId: string): NineZoneState;

// @internal (undocumented)
export function createDraggedTabState(tabId: DraggedTabState["tabId"], args?: Partial<DraggedTabState>): DraggedTabState;

// @internal (undocumented)
export function createFloatingWidgetState(id: FloatingWidgetState["id"], args?: Partial<FloatingWidgetState>): FloatingWidgetState;

// @internal (undocumented)
export function createHorizontalPanelState(side: HorizontalPanelSide, args?: Partial<HorizontalPanelState>): HorizontalPanelState;

// @internal
export function createNineZoneState(args?: Partial<NineZoneState>): NineZoneState;

// @internal (undocumented)
export function createPanelsState(args?: Partial<PanelsState>): PanelsState;

// @internal (undocumented)
export function createPanelState(side: PanelSide): {
    collapseOffset: number;
    collapsed: boolean;
    maxSize: number;
    minSize: number;
    pinned: boolean;
    resizable: boolean;
    side: PanelSide;
    size: undefined;
    widgets: never[];
    maxWidgetCount: number;
};

// @internal (undocumented)
export function createPopoutWidgetState(id: PopoutWidgetState["id"], args?: Partial<PopoutWidgetState>): PopoutWidgetState;

// @internal (undocumented)
export function createTabsState(args?: Partial<TabsState>): TabsState;

// @internal (undocumented)
export function createTabState(id: TabState["id"], args?: Partial<TabState>): TabState;

// @internal (undocumented)
export function createVerticalPanelState(side: VerticalPanelSide, args?: Partial<VerticalPanelState>): VerticalPanelState;

// @internal (undocumented)
export function createWidgetState(id: WidgetState["id"], tabs: WidgetState["tabs"], args?: Partial<WidgetState>): WidgetState;

// @internal
export class Css {
    // (undocumented)
    static toPercentage(px: number): string;
    // (undocumented)
    static toPx(px: number): string;
}

// @internal
export class CssProperties {
    // (undocumented)
    static fromBounds(props: RectangleProps): React_2.CSSProperties;
    // (undocumented)
    static fromPosition(props: PointProps): React_2.CSSProperties;
    // (undocumented)
    static transformFromPosition(props: PointProps): {
        transform: string;
    };
}

// @internal (undocumented)
export type CursorType = "nwse-resize" | "nesw-resize" | "ew-resize" | "ns-resize" | "grabbing";

// @internal (undocumented)
export const CursorTypeContext: React.Context<CursorType | undefined>;

// @beta
export class Dialog extends React.PureComponent<DialogProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @beta
export interface DialogProps extends CommonProps {
    children?: React.ReactNode;
    titleBar?: React.ReactNode;
}

// @beta @deprecated
export enum Direction {
    // (undocumented)
    Bottom = 4,
    // (undocumented)
    Left = 1,
    // (undocumented)
    Right = 3,
    // (undocumented)
    Top = 2
}

// @internal
export class DirectionHelpers {
    static readonly BOTTOM_CLASS_NAME = "nz-direction-bottom";
    // (undocumented)
    static getCssClassName(direction: Direction): string;
    // (undocumented)
    static getOrthogonalDirection(direction: Direction): OrthogonalDirection;
    static readonly LEFT_CLASS_NAME = "nz-direction-left";
    static readonly RIGHT_CLASS_NAME = "nz-direction-right";
    static readonly TOP_CLASS_NAME = "nz-direction-top";
}

// @internal
export enum DisabledResizeHandles {
    // (undocumented)
    Bottom = 8,
    // (undocumented)
    Left = 1,
    // (undocumented)
    None = 0,
    // (undocumented)
    Right = 4,
    // (undocumented)
    Top = 2
}

// @internal (undocumented)
export class DisabledResizeHandlesHelpers {
    // (undocumented)
    static isBottomDisabled(flags: DisabledResizeHandles): boolean;
    // (undocumented)
    static isLeftDisabled(flags: DisabledResizeHandles): boolean;
    // (undocumented)
    static isRightDisabled(flags: DisabledResizeHandles): boolean;
    // (undocumented)
    static isTopDisabled(flags: DisabledResizeHandles): boolean;
}

// @internal (undocumented)
export const Dock: React.NamedExoticComponent<object>;

// @internal
export function DockedToolSetting(props: ToolSettingProps): JSX.Element;

// @internal
export function DockedToolSettings(props: DockedToolSettingsProps): JSX.Element;

// @internal
export const DockedToolSettingsHandle: React.NamedExoticComponent<DockedToolSettingsHandleProps>;

// @internal
export interface DockedToolSettingsHandleProps extends CommonProps {
    // (undocumented)
    onResize?: (w: number) => void;
}

// @internal
export const DockedToolSettingsOverflow: React.MemoExoticComponent<React.ForwardRefExoticComponent<DockedToolSettingsOverflowProps & React.RefAttributes<HTMLDivElement>>>;

// @internal
export interface DockedToolSettingsOverflowProps extends CommonProps {
    onClick?: () => void;
    onResize?: (w: number) => void;
}

// @internal
export interface DockedToolSettingsProps extends CommonProps {
    children?: React.ReactNode;
    panelContainer?: React.ComponentType;
}

// @internal
export interface DockedToolSettingsState {
    // (undocumented)
    readonly type: "docked";
}

// @internal (undocumented)
export function dockWidgetContainer(state: NineZoneState, widgetTabId: string, idIsContainerId?: boolean): NineZoneState | undefined;

// @internal (undocumented)
export const DraggedPanelSideContext: React.Context<PanelSide | undefined>;

// @internal (undocumented)
export const DraggedResizeHandleContext: React.Context<FloatingWidgetResizeHandle | undefined>;

// @internal (undocumented)
export const DraggedTabContext: React.Context<boolean>;

// @internal
export interface DraggedTabState {
    // (undocumented)
    readonly home: FloatingWidgetHomeState;
    // (undocumented)
    readonly position: PointProps;
    // (undocumented)
    readonly tabId: TabState["id"];
}

// @internal (undocumented)
export const DraggedTabStateContext: React.Context<DraggedTabState | undefined>;

// @internal (undocumented)
export const DraggedWidgetIdContext: React.Context<string | undefined>;

// @internal
export class DraggedWidgetManager {
    // (undocumented)
    setLastPosition(lastPosition: PointProps, props: DraggedWidgetManagerProps): DraggedWidgetManagerProps;
}

// @internal
export interface DraggedWidgetManagerProps {
    // (undocumented)
    readonly id: WidgetZoneId;
    // (undocumented)
    readonly isUnmerge: boolean;
    // (undocumented)
    readonly lastPosition: PointProps;
    // (undocumented)
    readonly tabIndex: number;
}

// @internal
export class DragHandle extends React.PureComponent<DragHandleProps, DragHandleState> {
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    readonly state: DragHandleState;
}

// @internal
export interface DragHandleProps extends CommonProps {
    lastPosition?: PointProps;
    onClick?: () => void;
    onDrag?: (dragged: PointProps) => void;
    onDragEnd?: () => void;
    onDragStart?: (initialPosition: PointProps) => void;
}

// @internal (undocumented)
export interface DragItemDragStartArgs {
    // (undocumented)
    initialPointerPosition: Point;
}

// @internal (undocumented)
export class DragManager {
    // (undocumented)
    getDraggedIdOfType<T extends DragItem>(type: T["type"]): T["id"] | undefined;
    // (undocumented)
    handleDrag(x: number, y: number): void;
    // (undocumented)
    handleDragEnd(): void;
    // (undocumented)
    handleDragStart({ item, info }: HandleDragStartArgs): void;
    // (undocumented)
    handleTargetChanged(target: DragTarget | undefined): void;
    // (undocumented)
    isDragged(item: DragItem): boolean;
    // (undocumented)
    isDraggedType(type: DragItem["type"]): boolean;
    // (undocumented)
    get onDrag(): Event<DragEventHandler>;
    // (undocumented)
    get onDragEnd(): Event<DragEventHandler>;
    // (undocumented)
    get onDragStart(): Event<DragEventHandler>;
    }

// @internal (undocumented)
export const DragManagerContext: React.Context<DragManager>;

// @internal (undocumented)
export const DragProvider: React.NamedExoticComponent<DragProviderProps>;

// @internal (undocumented)
export interface DragProviderProps {
    // (undocumented)
    children?: React.ReactNode;
}

// @internal (undocumented)
export interface DragTabDragStartArgs extends DragItemDragStartArgs {
    // (undocumented)
    widgetSize: SizeProps;
}

// @internal (undocumented)
export type DragTarget = TabTarget | PanelTarget_2 | WidgetTarget_2;

// @internal
export function Ellipsis(props: CommonProps): JSX.Element;

// @internal (undocumented)
export function eqlOverflown(prev: readonly string[] | undefined, value: readonly string[]): boolean;

// @internal (undocumented)
export interface Event<T extends EventHandler> {
    // (undocumented)
    add(handler: T): void;
    // (undocumented)
    remove(handler: T): void;
}

// @internal (undocumented)
export class EventEmitter<T extends EventHandler> implements Event<T> {
    // (undocumented)
    add(handler: T): void;
    // (undocumented)
    emit(...args: Parameters<T>): void;
    // (undocumented)
    remove(handler: T): void;
    }

// @internal
export type EventHandler = (...args: any[]) => void;

// @internal
export class ExpandableButton extends React.PureComponent<ExpandableButtonProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface ExpandableButtonProps extends CommonProps {
    children?: React.ReactNode;
}

// @beta @deprecated
export class ExpandableItem extends React.PureComponent<ExpandableItemProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @beta @deprecated
export interface ExpandableItemProps extends CommonProps {
    hideIndicator?: boolean;
    isActive?: boolean;
    isDisabled?: boolean;
    panel?: React.ReactNode;
}

// @internal (undocumented)
export function findTab(state: NineZoneState, id: TabState["id"]): TabLocation | undefined;

// @internal (undocumented)
export function findWidget(state: NineZoneState, id: WidgetState["id"]): WidgetLocation | undefined;

// @internal
export function FloatingTab(): JSX.Element;

// @internal (undocumented)
export const FloatingWidget: React.NamedExoticComponent<FloatingWidgetProps>;

// @internal (undocumented)
export function floatingWidgetBringToFront(state: Draft<NineZoneState>, floatingWidgetId: FloatingWidgetState["id"]): void;

// @internal
export interface FloatingWidgetBringToFrontAction {
    // (undocumented)
    readonly id: FloatingWidgetState["id"];
    // (undocumented)
    readonly type: "FLOATING_WIDGET_BRING_TO_FRONT";
}

// @internal
export interface FloatingWidgetClearUserSizedAction {
    // (undocumented)
    readonly id: FloatingWidgetState["id"];
    // (undocumented)
    readonly type: "FLOATING_WIDGET_CLEAR_USER_SIZED";
}

// @internal (undocumented)
export function floatingWidgetClearUserSizedFlag(state: Draft<NineZoneState>, floatingWidgetId: FloatingWidgetState["id"]): void;

// @internal (undocumented)
export const FloatingWidgetContext: React.Context<FloatingWidgetState | undefined>;

// @internal
export interface FloatingWidgetHomeState {
    // (undocumented)
    readonly side: PanelSide;
    // (undocumented)
    readonly widgetId: WidgetState["id"] | undefined;
    // (undocumented)
    readonly widgetIndex: number;
}

// @internal (undocumented)
export const FloatingWidgetIdContext: React.Context<string | undefined>;

// @internal (undocumented)
export interface FloatingWidgetProps {
    // (undocumented)
    floatingWidget: FloatingWidgetState;
    // (undocumented)
    widget: WidgetState;
}

// @internal
export interface FloatingWidgetResizeAction {
    // (undocumented)
    readonly id: FloatingWidgetState["id"];
    // (undocumented)
    readonly resizeBy: RectangleProps;
    // (undocumented)
    readonly type: "FLOATING_WIDGET_RESIZE";
}

// @internal (undocumented)
export type FloatingWidgetResizeHandle = FloatingWidgetEdgeHandle | FloatingWidgetCornerHandle;

// @internal
export const FloatingWidgets: React.NamedExoticComponent<object>;

// @internal
export interface FloatingWidgetSendBackAction {
    // (undocumented)
    readonly id: FloatingWidgetState["id"];
    // (undocumented)
    readonly type: "FLOATING_WIDGET_SEND_BACK";
}

// @internal
export interface FloatingWidgetSetBoundsAction {
    // (undocumented)
    readonly bounds: RectangleProps;
    // (undocumented)
    readonly id: FloatingWidgetState["id"];
    // (undocumented)
    readonly type: "FLOATING_WIDGET_SET_BOUNDS";
}

// @internal
export interface FloatingWidgetsState {
    // (undocumented)
    readonly allIds: ReadonlyArray<FloatingWidgetState["id"]>;
    // (undocumented)
    readonly byId: {
        readonly [id: string]: FloatingWidgetState;
    };
}

// @internal (undocumented)
export const FloatingWidgetsStateContext: React.Context<FloatingWidgetsState>;

// @internal
export interface FloatingWidgetState {
    // (undocumented)
    readonly bounds: RectangleProps;
    // (undocumented)
    readonly home: FloatingWidgetHomeState;
    // (undocumented)
    readonly id: WidgetState["id"];
    // (undocumented)
    readonly userSized?: boolean;
}

// @internal (undocumented)
export function floatWidget(state: NineZoneState, widgetTabId: string, point?: PointProps, size?: SizeProps): NineZoneState | undefined;

// @internal @deprecated
export class Footer extends React.PureComponent<FooterProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @beta
export function FooterIndicator(props: FooterIndicatorProps): JSX.Element;

// @beta
export interface FooterIndicatorProps extends CommonProps {
    children?: React.ReactNode;
    isInFooterMode?: boolean;
    onClick?: (event: React.MouseEvent) => void;
    title?: string;
}

// @beta
export class FooterPopup extends React.PureComponent<FooterPopupProps> {
    // (undocumented)
    static readonly defaultProps: FooterPopupDefaultProps;
    // (undocumented)
    render(): JSX.Element;
}

// @beta
export enum FooterPopupContentType {
    Dialog = "nz-content-dialog",
    Panel = "nz-content-panel"
}

// @beta
export type FooterPopupDefaultProps = Pick<FooterPopupProps, "contentType">;

// @beta
export interface FooterPopupProps extends Partial<PopupProps> {
    contentType: FooterPopupContentType;
}

// @internal @deprecated
export interface FooterProps extends CommonProps {
    children?: React.ReactNode;
    isInFooterMode?: boolean;
    messages?: React.ReactNode;
    onMouseEnter?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
    onMouseLeave?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
    safeAreaInsets?: SafeAreaInsets;
}

// @public
export class FooterSeparator extends React.PureComponent<FooterSeparatorProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @public
export interface FooterSeparatorProps extends CommonProps, NoChildrenProps {
}

// @internal
export function getChildKey(child: React.ReactNode, index: number): string;

// @internal (undocumented)
export const getClosedWidgetTabIndex: (tabIndex: number) => number;

// @internal (undocumented)
export const getColumnZones: (id: WidgetZoneId) => WidgetZoneId[];

// @internal (undocumented)
export function getCursorClassName(type: CursorType): string;

// @internal (undocumented)
export const getDefaultAllowsMerging: (id: WidgetZoneId) => boolean;

// @internal
export const getDefaultNineZoneStagePanelManagerProps: () => NineZoneStagePanelManagerProps;

// @internal
export const getDefaultNineZoneStagePanelPaneManagerProps: () => NineZoneStagePanelPaneManagerProps;

// @internal
export const getDefaultNineZoneStagePanelsManagerProps: () => NineZoneStagePanelsManagerProps;

// @internal
export const getDefaultStagePanelManagerProps: () => StagePanelManagerProps;

// @internal
export const getDefaultStagePanelsManagerProps: () => StagePanelsManagerProps;

// @internal (undocumented)
export const getDefaultToolSettingsWidgetManagerProps: () => ToolSettingsWidgetManagerProps;

// @internal (undocumented)
export const getDefaultWidgetHorizontalAnchor: (id: WidgetZoneId) => HorizontalAnchor;

// @internal (undocumented)
export const getDefaultWidgetManagerProps: (id: WidgetZoneId) => WidgetManagerProps;

// @internal (undocumented)
export const getDefaultWidgetVerticalAnchor: (id: WidgetZoneId) => VerticalAnchor.Bottom | VerticalAnchor.Middle;

// @internal (undocumented)
export const getDefaultZoneManagerProps: (id: WidgetZoneId) => ZoneManagerProps;

// @internal
export const getDefaultZonesManagerProps: () => ZonesManagerProps;

// @internal
export const getDefaultZonesManagerWidgetsProps: () => ZonesManagerWidgetsProps;

// @internal
export const getDefaultZonesManagerZonesProps: () => ZonesManagerZonesProps;

// @internal (undocumented)
export const getDragDistance: (from: Point, to: Point, direction: Direction) => number;

// @internal
export function getOverflown(width: number, docked: ReadonlyArray<readonly [string, number]>, overflowWidth: number, activeIndex?: number): string[];

// @internal (undocumented)
export function getResizeBy(handle: FloatingWidgetResizeHandle, offset: PointProps): Rectangle;

// @internal (undocumented)
export const getToolbarDirection: (expandsTo: Direction) => OrthogonalDirection;

// @internal
export const getToolbarItemProps: <TProps extends {}>(props: TProps) => ToolbarItemProps<ToolbarItem>;

// @internal (undocumented)
export function getUniqueId(): string;

// @internal (undocumented)
export const getWindowResizeSettings: (zoneId: WidgetZoneId) => ZoneWindowResizeSettings;

// @internal (undocumented)
export const getZoneCell: (id: ZoneId) => Cell;

// @internal (undocumented)
export const getZoneIdFromCell: (cell: CellProps) => WidgetZoneId;

// @alpha @deprecated
export class Group extends React.PureComponent<GroupProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @alpha @deprecated
export class GroupColumn extends React.PureComponent<GroupColumnProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @alpha @deprecated
export interface GroupColumnProps extends CommonProps {
    children?: React.ReactNode;
}

// @alpha @deprecated
export interface GroupProps extends CommonProps, NoChildrenProps {
    columns?: React.ReactNode;
    title?: string;
}

// @internal
export class GroupTool extends React.PureComponent<GroupToolProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export class GroupToolExpander extends React.PureComponent<GroupToolExpanderProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface GroupToolExpanderProps extends Omit<GroupToolProps, "isActive" | "children">, NoChildrenProps {
}

// @internal
export interface GroupToolProps extends CommonProps {
    badge?: React.ReactNode;
    children?: React.ReactNode;
    icon?: React.ReactNode;
    isActive?: boolean;
    isDisabled?: boolean;
    isFocused?: boolean;
    label?: string;
    onClick?: () => void;
    onPointerUp?: () => void;
}

// @internal (undocumented)
export class GrowBottom extends GrowStrategy {
    // (undocumented)
    getDistanceToRoot(bounds: RectangleProps, zonesBounds: RectangleProps): number;
    // (undocumented)
    getDistanceToZoneToShrink(zoneId: WidgetZoneId, zoneToShrinkId: WidgetZoneId, props: ZonesManagerProps): number;
    // (undocumented)
    getShrinkStrategy(): UpdateWindowResizeSettings;
    // (undocumented)
    getZonesToShrink(zoneId: WidgetZoneId, props: ZonesManagerProps): WidgetZoneId[];
    // (undocumented)
    resize(bounds: RectangleProps, growBy: number): RectangleProps;
}

// @internal (undocumented)
export class GrowLeft extends GrowStrategy {
    // (undocumented)
    getDistanceToRoot(bounds: RectangleProps): number;
    // (undocumented)
    getDistanceToZoneToShrink(zoneId: WidgetZoneId, zoneToShrinkId: WidgetZoneId, props: ZonesManagerProps): number;
    // (undocumented)
    getMaxResize(zoneId: WidgetZoneId, props: ZonesManagerProps): number;
    // (undocumented)
    getShrinkStrategy(): UpdateWindowResizeSettings;
    // (undocumented)
    getZonesToShrink(zoneId: WidgetZoneId, props: ZonesManagerProps): WidgetZoneId[];
    // (undocumented)
    resize(bounds: RectangleProps, growBy: number): RectangleProps;
}

// @internal (undocumented)
export class GrowRight extends GrowStrategy {
    // (undocumented)
    getDistanceToRoot(bounds: RectangleProps, zonesBounds: RectangleProps): number;
    // (undocumented)
    getDistanceToZoneToShrink(zoneId: WidgetZoneId, zoneToShrinkId: WidgetZoneId, props: ZonesManagerProps): number;
    // (undocumented)
    getMaxResize(zoneId: WidgetZoneId, props: ZonesManagerProps): number;
    // (undocumented)
    getShrinkStrategy(): UpdateWindowResizeSettings;
    // (undocumented)
    getZonesToShrink(zoneId: WidgetZoneId, props: ZonesManagerProps): WidgetZoneId[];
    // (undocumented)
    resize(bounds: RectangleProps, growBy: number): RectangleProps;
}

// @internal (undocumented)
export abstract class GrowStrategy implements ResizeStrategy {
    constructor(manager: ZonesManager);
    // (undocumented)
    abstract getDistanceToRoot(bounds: RectangleProps, zonesBounds: RectangleProps): number;
    // (undocumented)
    abstract getDistanceToZoneToShrink(zoneId: WidgetZoneId, zoneToShrinkId: WidgetZoneId, props: ZonesManagerProps): number;
    // (undocumented)
    getMaxResize(zoneId: WidgetZoneId, props: ZonesManagerProps): number;
    // (undocumented)
    abstract getShrinkStrategy(): ResizeStrategy;
    // (undocumented)
    abstract getZonesToShrink(zoneId: WidgetZoneId, props: ZonesManagerProps): WidgetZoneId[];
    // (undocumented)
    readonly manager: ZonesManager;
    // (undocumented)
    abstract resize(bounds: RectangleProps, growBy: number): RectangleProps;
    // (undocumented)
    tryResize(zoneId: WidgetZoneId, resizeBy: number, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    tryResizeFloating(zoneId: WidgetZoneId, resizeBy: number, props: ZonesManagerProps): ZonesManagerProps;
}

// @internal (undocumented)
export class GrowTop extends GrowStrategy {
    // (undocumented)
    getDistanceToRoot(bounds: RectangleProps): number;
    // (undocumented)
    getDistanceToZoneToShrink(zoneId: WidgetZoneId, zoneToShrinkId: WidgetZoneId, props: ZonesManagerProps): number;
    // (undocumented)
    getShrinkStrategy(): UpdateWindowResizeSettings;
    // (undocumented)
    getZonesToShrink(zoneId: WidgetZoneId, props: ZonesManagerProps): WidgetZoneId[];
    // (undocumented)
    resize(bounds: RectangleProps, growBy: number): RectangleProps;
}

// @internal
export enum HandleMode {
    // (undocumented)
    Hovered = 0,
    // (undocumented)
    Timedout = 2,
    // (undocumented)
    Visible = 1
}

// @internal
export class HandleModeHelpers {
    // (undocumented)
    static getCssClassName(mode: HandleMode): string;
    static readonly HOVERED_CLASS_NAME = "nz-handle-hovered";
    static readonly TIMEDOUT_CLASS_NAME = "nz-handle-timedout";
    static readonly VISIBLE_CLASS_NAME = "nz-handle-visible";
}

// @internal (undocumented)
export function handleToCursorType(handle: FloatingWidgetResizeHandle): CursorType;

// @beta @deprecated
export enum HorizontalAnchor {
    // (undocumented)
    Left = 0,
    // (undocumented)
    Right = 1
}

// @internal
export class HorizontalAnchorHelpers {
    // (undocumented)
    static getCssClassName(anchor: HorizontalAnchor): string;
    static readonly LEFT_CLASS_NAME = "nz-left-anchor";
    static readonly RIGHT_CLASS_NAME = "nz-right-anchor";
}

// @internal (undocumented)
export type HorizontalPanelSide = TopPanelSide | BottomPanelSide;

// @internal
export interface HorizontalPanelState extends PanelState {
    // (undocumented)
    readonly side: HorizontalPanelSide;
    // (undocumented)
    readonly span: boolean;
}

// @internal (undocumented)
export const IconOnlyOnWidgetTabContext: React.Context<boolean>;

// @internal (undocumented)
export function initSizeAndPositionProps<T, K extends KeysOfType<T, SizeAndPositionProps | undefined>>(obj: T, key: K, inValue: SizeAndPositionProps): void;

// @internal (undocumented)
export function isFloatingLocation(location: TabLocation): location is FloatingLocation;

// @internal (undocumented)
export function isFloatingWidgetLocation(location: WidgetLocation): location is FloatingLocation;

// @internal (undocumented)
export const isHorizontalPanelSide: (side: PanelSide) => side is HorizontalPanelSide;

// @internal (undocumented)
export function isHorizontalPanelState(state: PanelState): state is HorizontalPanelState;

// @internal (undocumented)
export function isPanelLocation(location: TabLocation): location is PanelLocation;

// @internal (undocumented)
export function isPopoutLocation(location: TabLocation): location is PopoutLocation;

// @internal (undocumented)
export function isPopoutWidgetLocation(location: WidgetLocation): location is PopoutLocation;

// @internal (undocumented)
export function isTabTarget(target: DragTarget): target is TabTarget;

// @beta @deprecated
export class Item extends React.PureComponent<ItemProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @beta @deprecated
export interface ItemProps extends CommonProps {
    badge?: React.ReactNode;
    icon?: React.ReactNode;
    isActive?: boolean;
    isDisabled?: boolean;
    onClick?: () => void;
    onKeyDown?: (e: React.KeyboardEvent) => void;
    onSizeKnown?: (size: SizeProps) => void;
    title?: string;
}

// @internal
export class Items extends React.PureComponent<ItemsProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface ItemsProps extends CommonProps {
    children?: React.ReactNode;
    direction: OrthogonalDirection;
}

// @internal (undocumented)
export type LeftPanelSide = "left";

// @internal (undocumented)
export const MeasureContext: React.Context<() => Rectangle>;

// @internal
export class MergeTarget extends React.PureComponent<MergeTargetProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface MergeTargetProps extends CommonProps {
    onTargetChanged?: (isTargeted: boolean) => void;
}

// @internal @deprecated
export class Message extends React.PureComponent<StatusMessageProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export class MessageButton extends React.PureComponent<MessageButtonProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface MessageButtonProps extends CommonProps {
    children?: React.ReactNode;
    onClick?: () => void;
}

// @internal
export class MessageCenter extends React.PureComponent<MessageCenterProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export class MessageCenterDialog extends React.PureComponent<MessageCenterDialogProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface MessageCenterDialogProps extends CommonProps {
    buttons?: React.ReactNode;
    children?: React.ReactNode;
    // (undocumented)
    prompt?: string;
    tabs?: React.ReactNode;
    title?: string;
}

// @internal
export class MessageCenterMessage extends React.PureComponent<MessageCenterMessageProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface MessageCenterMessageProps extends CommonProps {
    children?: React.ReactNode;
    icon?: React.ReactNode;
}

// @internal
export interface MessageCenterProps extends FooterIndicatorProps {
    children?: string;
    indicatorRef?: React.Ref<HTMLDivElement>;
    label?: string;
    onClick?: () => void;
    targetRef?: React.Ref<HTMLDivElement>;
}

// @internal
export class MessageCenterTab extends React.PureComponent<MessageCenterTabProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface MessageCenterTabProps extends CommonProps {
    children?: React.ReactNode;
    isActive?: boolean;
    onClick?: () => void;
}

// @internal
export class MessageHyperlink extends React.PureComponent<MessageHyperlinkProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface MessageHyperlinkProps extends CommonProps {
    children?: string;
    onClick?: () => void;
}

// @internal
export class MessageLayout extends React.PureComponent<MessageLayoutProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface MessageLayoutProps extends CommonProps {
    buttons?: React.ReactNode;
    children?: React.ReactNode;
    progress?: React.ReactNode;
}

// @internal
export class MessageProgress extends React.PureComponent<ProgressProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export const NavigationArea: React.NamedExoticComponent<NavigationAreaProps>;

// @internal
export interface NavigationAreaProps extends CommonProps, NoChildrenProps {
    horizontalToolbar?: React.ReactNode;
    navigationAid?: React.ReactNode;
    onMouseEnter?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
    onMouseLeave?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
    verticalToolbar?: React.ReactNode;
}

// @internal @deprecated
export class NestedGroup extends React.PureComponent<NestedGroupProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface NestedGroupProps extends GroupProps {
    onBack?: () => void;
    onBackPointerUp?: () => void;
}

// @internal
export interface NestedStagePanelKey<TProps extends NestedStagePanelsManagerProps> {
    // (undocumented)
    readonly id: NestedStagePanelsId<TProps>;
    // (undocumented)
    readonly type: StagePanelType;
}

// @internal
export type NestedStagePanelsId<TProps extends NestedStagePanelsManagerProps> = Extract<keyof TProps["panels"], string | number>;

// @internal
export class NestedStagePanelsManager {
    // (undocumented)
    getPanelsManager<TProps extends NestedStagePanelsManagerProps>(id: NestedStagePanelsId<TProps>): StagePanelsManager;
    // (undocumented)
    resize<TProps extends NestedStagePanelsManagerProps>(panel: NestedStagePanelKey<TProps>, resizeBy: number, props: TProps): TProps;
    // (undocumented)
    setIsCollapsed<TProps extends NestedStagePanelsManagerProps>(panel: NestedStagePanelKey<TProps>, isCollapsed: boolean, props: TProps): TProps;
    // (undocumented)
    setSize<TProps extends NestedStagePanelsManagerProps>(panel: NestedStagePanelKey<TProps>, size: number, props: TProps): TProps;
}

// @internal
export interface NestedStagePanelsManagerProps {
    // (undocumented)
    readonly panels: {
        readonly [id: string]: StagePanelsManagerProps;
    };
}

// @internal
export function NineZone(props: NineZoneProps): JSX.Element;

// @internal
export type NineZoneActionTypes = ResizeAction | PanelToggleCollapsedAction | PanelSetCollapsedAction | PanelSetSizeAction | PanelToggleSpanAction | PanelTogglePinnedAction | PanelInitializeAction | FloatingWidgetResizeAction | FloatingWidgetSetBoundsAction | FloatingWidgetBringToFrontAction | FloatingWidgetSendBackAction | FloatingWidgetClearUserSizedAction | PopoutWidgetSendBackAction | PanelWidgetDragStartAction | WidgetDragAction | WidgetDragEndAction | WidgetTabClickAction | WidgetTabDoubleClickAction | WidgetTabDragStartAction | WidgetTabDragAction | WidgetTabDragEndAction | WidgetTabPopoutAction | ToolSettingsDragStartAction | ToolSettingsDockAction;

// @internal (undocumented)
export const NineZoneContext: React.Context<NineZoneState>;

// @internal
export type NineZoneDispatch = (action: NineZoneActionTypes) => void;

// @internal (undocumented)
export const NineZoneDispatchContext: React.Context<NineZoneDispatch>;

// @internal (undocumented)
export interface NineZoneLabels {
    // (undocumented)
    dockToolSettingsTitle?: string;
    // (undocumented)
    moreToolSettingsTitle?: string;
    // (undocumented)
    moreWidgetsTitle?: string;
    // (undocumented)
    pinPanelTitle?: string;
    // (undocumented)
    popoutActiveTab?: string;
    // (undocumented)
    resizeGripTitle?: string;
    // (undocumented)
    sendWidgetHomeTitle?: string;
    // (undocumented)
    toolSettingsHandleTitle?: string;
    // (undocumented)
    unpinPanelTitle?: string;
}

// @internal (undocumented)
export const NineZoneLabelsContext: React.Context<NineZoneLabels | undefined>;

// @internal
export class NineZoneManager {
    // (undocumented)
    getHiddenWidgets(): NineZoneManagerHiddenWidgets;
    // (undocumented)
    getNestedPanelsManager(): NineZoneNestedStagePanelsManager;
    // (undocumented)
    getPanelTarget(): NineZoneManagerPanelTarget | undefined;
    // (undocumented)
    getPaneTarget(): NineZoneManagerPaneTarget | undefined;
    // (undocumented)
    getZonesManager(): ZonesManager;
    // (undocumented)
    handleWidgetTabClick<TProps extends NineZoneManagerProps>(widgetId: WidgetZoneId, tabIndex: number, props: TProps): TProps;
    // (undocumented)
    handleWidgetTabDragEnd<TProps extends NineZoneManagerProps>(props: TProps): TProps;
    // (undocumented)
    handleWidgetTabDragStart<TProps extends NineZoneManagerProps>(args: WidgetTabDragStartArguments, props: TProps): TProps;
    // (undocumented)
    hideWidget<TProps extends NineZoneManagerProps>(widgetId: WidgetZoneId, props: TProps): TProps;
    // (undocumented)
    setNested<TProps extends NineZoneManagerProps>(nested: TProps["nested"], props: TProps): TProps;
    // (undocumented)
    setPanelTarget(target: NineZoneManagerPanelTarget | undefined): void;
    // (undocumented)
    setPaneTarget(target: NineZoneManagerPaneTarget | undefined): void;
    // (undocumented)
    setProp<TProps extends NineZoneManagerProps, TKey extends keyof TProps>(value: TProps[TKey], key: TKey, props: TProps): TProps;
    // (undocumented)
    setZones<TProps extends NineZoneManagerProps>(zones: TProps["zones"], props: TProps): TProps;
    // (undocumented)
    showWidget<TProps extends NineZoneManagerProps>(widgetId: WidgetZoneId, props: TProps): TProps;
    }

// @internal (undocumented)
export interface NineZoneManagerHiddenWidget {
    // (undocumented)
    panel?: {
        key: NestedStagePanelKey<NestedStagePanelsManagerProps>;
    };
}

// @internal (undocumented)
export type NineZoneManagerHiddenWidgets = {
    readonly [id in WidgetZoneId]: NineZoneManagerHiddenWidget;
};

// @internal
export interface NineZoneManagerPanelTarget {
    // (undocumented)
    readonly panelId: string | number;
    // (undocumented)
    readonly panelType: StagePanelType;
}

// @internal
export interface NineZoneManagerPaneTarget extends NineZoneManagerPanelTarget {
    // (undocumented)
    readonly paneIndex: number;
}

// @internal
export interface NineZoneManagerProps {
    // (undocumented)
    readonly nested: NineZoneNestedStagePanelsManagerProps;
    // (undocumented)
    readonly zones: ZonesManagerProps;
}

// @internal
export class NineZoneNestedStagePanelsManager extends NestedStagePanelsManager {
    // (undocumented)
    addWidget<TProps extends NineZoneNestedStagePanelsManagerProps>(widget: WidgetZoneId, panel: NestedStagePanelKey<TProps>, paneIndex: number | undefined, props: TProps): TProps;
    // (undocumented)
    getPanelsManager<TProps extends NestedStagePanelsManagerProps>(id: NestedStagePanelsId<TProps>): NineZoneStagePanelsManager;
    // (undocumented)
    removeWidget<TProps extends NineZoneNestedStagePanelsManagerProps>(widget: WidgetZoneId, panel: NestedStagePanelKey<TProps>, props: TProps): TProps;
}

// @internal
export interface NineZoneNestedStagePanelsManagerProps extends NestedStagePanelsManagerProps {
    // (undocumented)
    readonly panels: {
        readonly [id: string]: NineZoneStagePanelsManagerProps;
    };
}

// @internal
export interface NineZoneProps {
    // (undocumented)
    children?: React.ReactNode;
    // (undocumented)
    dispatch: NineZoneDispatch;
    // (undocumented)
    labels?: NineZoneLabels;
    // (undocumented)
    showWidgetIcon?: boolean;
    // (undocumented)
    state: NineZoneState;
    // (undocumented)
    tab?: React.ReactNode;
    // (undocumented)
    toolSettingsContent?: React.ReactNode;
    // (undocumented)
    widgetContent?: React.ReactNode;
}

// @internal (undocumented)
export function NineZoneProvider(props: NineZoneProviderProps): JSX.Element;

// @internal (undocumented)
export interface NineZoneProviderProps extends NineZoneProps {
    // (undocumented)
    measure: () => Rectangle;
}

// @internal
export class NineZoneStagePanelManager extends StagePanelManager {
    // (undocumented)
    addWidget<TProps extends NineZoneStagePanelManagerProps>(widgetId: WidgetZoneId, paneIndex: number | undefined, props: TProps): TProps;
    // (undocumented)
    findWidget<TProps extends NineZoneStagePanelManagerProps>(widgetId: WidgetZoneId, props: TProps): {
        paneIndex: number;
        widgetIndex: number;
    } | undefined;
    // (undocumented)
    static getHorizontalAnchor(type: StagePanelType): HorizontalAnchor;
    // (undocumented)
    getPaneManager(paneIndex: number): NineZoneStagePanelPaneManager;
    // (undocumented)
    static getVerticalAnchor(type: StagePanelType): VerticalAnchor.BottomPanel | VerticalAnchor.Middle | VerticalAnchor.TopPanel;
    // (undocumented)
    removeWidget<TProps extends NineZoneStagePanelManagerProps>(widgetId: WidgetZoneId, props: TProps): TProps;
}

// @internal
export interface NineZoneStagePanelManagerProps extends StagePanelManagerProps {
    // (undocumented)
    readonly panes: ReadonlyArray<NineZoneStagePanelPaneManagerProps>;
}

// @internal
export class NineZoneStagePanelPaneManager {
    // (undocumented)
    addWidget<TProps extends NineZoneStagePanelPaneManagerProps>(widgetId: WidgetZoneId, props: TProps): TProps;
    // (undocumented)
    removeWidget<TProps extends NineZoneStagePanelPaneManagerProps>(widgetId: WidgetZoneId, props: TProps): TProps;
}

// @internal
export interface NineZoneStagePanelPaneManagerProps {
    // (undocumented)
    readonly widgets: ReadonlyArray<WidgetZoneId>;
}

// @internal
export class NineZoneStagePanelsManager extends StagePanelsManager {
    // (undocumented)
    addWidget<TProps extends NineZoneStagePanelsManagerProps>(widget: WidgetZoneId, type: StagePanelType, paneIndex: number | undefined, props: TProps): TProps;
    // (undocumented)
    findWidget<TProps extends NineZoneStagePanelsManagerProps>(widgetId: WidgetZoneId, props: TProps): {
        paneIndex: number;
        widgetIndex: number;
        type: StagePanelType;
    } | undefined;
    // (undocumented)
    getPanelManager(type: StagePanelType): NineZoneStagePanelManager;
    // (undocumented)
    removeWidget<TProps extends NineZoneStagePanelsManagerProps>(widget: WidgetZoneId, type: StagePanelType, props: TProps): TProps;
}

// @internal
export interface NineZoneStagePanelsManagerProps extends StagePanelsManagerProps {
    // (undocumented)
    readonly bottom: NineZoneStagePanelManagerProps;
    // (undocumented)
    readonly left: NineZoneStagePanelManagerProps;
    // (undocumented)
    readonly right: NineZoneStagePanelManagerProps;
    // (undocumented)
    readonly top: NineZoneStagePanelManagerProps;
}

// @internal
export interface NineZoneState {
    // (undocumented)
    readonly draggedTab: DraggedTabState | undefined;
    // (undocumented)
    readonly floatingWidgets: FloatingWidgetsState;
    // (undocumented)
    readonly panels: PanelsState;
    // (undocumented)
    readonly popoutWidgets: PopoutWidgetsState;
    // (undocumented)
    readonly size: SizeProps;
    // (undocumented)
    readonly tabs: TabsState;
    // (undocumented)
    readonly toolSettings: ToolSettingsState;
    // (undocumented)
    readonly widgets: WidgetsState;
}

// @internal
export const NineZoneStateReducer: (state: NineZoneState, action: NineZoneActionTypes) => NineZoneState;

// @internal
export const offsetAndContainInContainer: (tooltipBounds: RectangleProps, containerSize: SizeProps, offset?: PointProps) => Point;

// @internal (undocumented)
export function onOverflowLabelAndEditorResize(): void;

// @internal @deprecated
export enum OrthogonalDirection {
    // (undocumented)
    Horizontal = 1,
    // (undocumented)
    Vertical = 0
}

// @internal
export class OrthogonalDirectionHelpers {
    // (undocumented)
    static getCssClassName(direction: OrthogonalDirection): string;
    static readonly HORIZONTAL_CLASS_NAME = "nz-horizontal";
    // (undocumented)
    static inverse(direction: OrthogonalDirection): OrthogonalDirection;
    static readonly VERTICAL_CLASS_NAME = "nz-vertical";
}

// @internal
export class Outline extends React.PureComponent<OutlineProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface OutlineProps extends CommonProps {
    bounds: RectangleProps;
}

// @internal
export class Overflow extends React.PureComponent<OverflowProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface OverflowProps extends ExpandableItemProps {
    onClick?: () => void;
}

// @alpha @deprecated
export class Panel extends React.PureComponent<PanelProps> {
    // @deprecated
    static get isPanelOpen(): boolean;
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface PanelInitializeAction {
    // (undocumented)
    readonly side: PanelSide;
    // (undocumented)
    readonly size: number;
    // (undocumented)
    readonly type: "PANEL_INITIALIZE";
}

// @alpha @deprecated
export interface PanelProps extends CommonProps {
    children?: React.ReactNode;
}

// @internal
export interface PanelSetCollapsedAction {
    // (undocumented)
    readonly collapsed: boolean;
    // (undocumented)
    readonly side: PanelSide;
    // (undocumented)
    readonly type: "PANEL_SET_COLLAPSED";
}

// @internal
export interface PanelSetSizeAction {
    // (undocumented)
    readonly side: PanelSide;
    // (undocumented)
    readonly size: number;
    // (undocumented)
    readonly type: "PANEL_SET_SIZE";
}

// @internal
export type PanelSide = VerticalPanelSide | HorizontalPanelSide;

// @internal (undocumented)
export const PanelSideContext: React.Context<PanelSide | undefined>;

// @internal (undocumented)
export const panelSides: [LeftPanelSide, RightPanelSide, TopPanelSide, BottomPanelSide];

// @internal
export class PanelsProvider extends React.PureComponent<PanelsProviderProps> {
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    render(): React.ReactNode;
    }

// @internal
export interface PanelsProviderProps {
    children?: (items: React.ReactNode) => React.ReactNode;
    items?: React.ReactNode;
    panels: HTMLElement | null;
}

// @internal
export interface PanelsState {
    // (undocumented)
    readonly bottom: HorizontalPanelState;
    // (undocumented)
    readonly left: VerticalPanelState;
    // (undocumented)
    readonly right: VerticalPanelState;
    // (undocumented)
    readonly top: HorizontalPanelState;
}

// @internal (undocumented)
export const PanelsStateContext: React.Context<PanelsState>;

// @internal
export interface PanelState {
    // (undocumented)
    readonly collapsed: boolean;
    // (undocumented)
    readonly collapseOffset: number;
    // (undocumented)
    readonly maxSize: number;
    // (undocumented)
    readonly maxWidgetCount: number;
    // (undocumented)
    readonly minSize: number;
    // (undocumented)
    readonly pinned: boolean;
    // (undocumented)
    readonly resizable: boolean;
    // (undocumented)
    readonly side: PanelSide;
    // (undocumented)
    readonly size: number | undefined;
    // (undocumented)
    readonly widgets: ReadonlyArray<WidgetState["id"]>;
}

// @internal (undocumented)
export const PanelStateContext: React.Context<PanelState | undefined>;

// @internal (undocumented)
export const PanelTarget: React.NamedExoticComponent<object>;

// @internal
export interface PanelToggleCollapsedAction {
    // (undocumented)
    readonly side: PanelSide;
    // (undocumented)
    readonly type: "PANEL_TOGGLE_COLLAPSED";
}

// @internal
export interface PanelTogglePinnedAction {
    // (undocumented)
    readonly side: PanelSide;
    // (undocumented)
    readonly type: "PANEL_TOGGLE_PINNED";
}

// @internal
export interface PanelToggleSpanAction {
    // (undocumented)
    readonly side: HorizontalPanelSide;
    // (undocumented)
    readonly type: "PANEL_TOGGLE_SPAN";
}

// @internal (undocumented)
export const PanelWidget: React.MemoExoticComponent<React.ForwardRefExoticComponent<PanelWidgetProps & React.RefAttributes<WidgetComponent>>>;

// @internal
export interface PanelWidgetDragStartAction {
    // (undocumented)
    readonly bounds: RectangleProps;
    // (undocumented)
    readonly id: WidgetState["id"];
    // (undocumented)
    readonly newFloatingWidgetId: FloatingWidgetState["id"];
    // (undocumented)
    readonly side: PanelSide;
    // (undocumented)
    readonly type: "PANEL_WIDGET_DRAG_START";
}

// @internal (undocumented)
export interface PanelWidgetProps {
    // (undocumented)
    onBeforeTransition(): void;
    // (undocumented)
    onPrepareTransition(): void;
    // (undocumented)
    onTransitionEnd(): void;
    // (undocumented)
    size: number | undefined;
    // (undocumented)
    transition: "init" | "transition" | undefined;
    // (undocumented)
    widgetId: WidgetState["id"];
}

// @internal (undocumented)
export const PinToggle: React.NamedExoticComponent<object>;

// @internal
export class PointerCaptor extends React.PureComponent<PointerCaptorProps> {
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    render(): JSX.Element;
}

// @internal (undocumented)
export interface PointerCaptorArgs {
    // (undocumented)
    readonly clientX: number;
    // (undocumented)
    readonly clientY: number;
}

// @internal (undocumented)
export type PointerCaptorEvent = MouseEvent | TouchEvent;

// @internal
export interface PointerCaptorProps extends CommonProps {
    isPointerDown: boolean;
    onClick?: () => void;
    onPointerDown?: (e: PointerEvent) => void;
    onPointerMove?: (e: PointerEvent) => void;
    onPointerUp?: (e: PointerEvent) => void;
}

// @internal (undocumented)
export const PopoutToggle: React.NamedExoticComponent<object>;

// @internal
export interface PopoutWidgetSendBackAction {
    // (undocumented)
    readonly id: PopoutWidgetState["id"];
    // (undocumented)
    readonly type: "POPOUT_WIDGET_SEND_BACK";
}

// @internal
export interface PopoutWidgetsState {
    // (undocumented)
    readonly allIds: ReadonlyArray<PopoutWidgetState["id"]>;
    // (undocumented)
    readonly byId: {
        readonly [id: string]: PopoutWidgetState;
    };
}

// @internal
export interface PopoutWidgetState {
    // (undocumented)
    readonly bounds: RectangleProps;
    // (undocumented)
    readonly home: FloatingWidgetHomeState;
    // (undocumented)
    readonly id: WidgetState["id"];
}

// @internal (undocumented)
export function popoutWidgetToChildWindow(state: NineZoneState, widgetTabId: string, point?: PointProps, size?: SizeProps): NineZoneState | undefined;

// @internal
export interface ProgressProps extends CommonProps, NoChildrenProps {
    progress: number;
    status: Status;
}

// @internal (undocumented)
export const RECTANGULAR_DEFAULT_MIN_HEIGHT = 220;

// @internal (undocumented)
export const RECTANGULAR_DEFAULT_MIN_WIDTH = 296;

// @internal
export function removeTab(state: Draft<NineZoneState>, tabId: TabState["id"]): void;

// @internal
export function removeWidgetTab(state: Draft<NineZoneState>, tabId: TabState["id"]): void;

// @internal
export interface ResizeAction {
    // (undocumented)
    readonly size: SizeProps;
    // (undocumented)
    readonly type: "RESIZE";
}

// @internal
export enum ResizeDirection {
    // (undocumented)
    EastWest = 0,
    // (undocumented)
    NorthEast_SouthWest = 2,
    // (undocumented)
    NorthSouth = 1,
    // (undocumented)
    NorthWest_SouthEast = 3
}

// @internal
export class ResizeDirectionHelpers {
    static readonly EW_CLASS_NAME = "nz-direction-ew";
    // (undocumented)
    static getCssClassName(direction: ResizeDirection): string;
    static readonly NE_SW_CLASS_NAME = "nz-direction-ne-sw";
    static readonly NS_CLASS_NAME = "nz-direction-ns";
    static readonly NW_SE_CLASS_NAME = "nz-direction-nw-se";
}

// @internal
export class ResizeGrip extends React.PureComponent<ResizeGripProps, ResizeGripState> {
    // (undocumented)
    render(): JSX.Element;
    // (undocumented)
    readonly state: ResizeGripState;
}

// @internal
export interface ResizeGripProps extends CommonProps {
    direction: ResizeDirection;
    onClick?: () => void;
    onResize?: (args: ResizeGripResizeArgs) => void;
    onResizeEnd?: (args: ResizeGripResizeArgs) => void;
    onResizeStart?: (args: ResizeGripResizeArgs) => void;
}

// @internal
export interface ResizeGripResizeArgs {
    readonly bounds: RectangleProps;
    readonly position: PointProps;
}

// @internal
export enum ResizeHandle {
    // (undocumented)
    Bottom = 3,
    // (undocumented)
    Left = 0,
    // (undocumented)
    Right = 2,
    // (undocumented)
    Top = 1
}

// @internal (undocumented)
export interface ResizeStrategy {
    // (undocumented)
    getMaxResize(zoneId: WidgetZoneId, props: ZonesManagerProps): number;
    // (undocumented)
    tryResize(zoneId: WidgetZoneId, resizeBy: number, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    tryResizeFloating(zoneId: WidgetZoneId, resizeBy: number, props: ZonesManagerProps): ZonesManagerProps;
}

// @internal (undocumented)
export function restrainInitialWidgetSize(size: SizeProps, nzSize: SizeProps): SizeProps;

// @internal (undocumented)
export type RightPanelSide = "right";

// @beta
export enum SafeAreaInsets {
    // (undocumented)
    All = 15,
    // (undocumented)
    Bottom = 1,
    // (undocumented)
    Left = 2,
    // (undocumented)
    None = 0,
    // (undocumented)
    Right = 4,
    // (undocumented)
    Top = 8
}

// @internal (undocumented)
export class SafeAreaInsetsHelpers {
    // (undocumented)
    static getCssClassNames: (flags: SafeAreaInsets) => {
        "nz-safe-area-bottom": boolean;
        "nz-safe-area-left": boolean;
        "nz-safe-area-right": boolean;
        "nz-safe-area-top": boolean;
    };
    // (undocumented)
    static isBottom(flags: SafeAreaInsets): boolean;
    // (undocumented)
    static isLeft(flags: SafeAreaInsets): boolean;
    // (undocumented)
    static isRight(flags: SafeAreaInsets): boolean;
    // (undocumented)
    static isTop(flags: SafeAreaInsets): boolean;
}

// @internal
export const ScrollableWidgetContent: React.NamedExoticComponent<ScrollableWidgetContentProps>;

// @internal
export interface ScrollableWidgetContentProps {
    // (undocumented)
    children?: React.ReactNode;
    itemId?: string;
}

// @internal (undocumented)
export const SendBack: React.NamedExoticComponent<object>;

// @internal (undocumented)
export function setFloatingWidgetContainerBounds(state: NineZoneState, floatingWidgetId: string, bounds: RectangleProps): NineZoneState;

// @internal (undocumented)
export function setRectangleProps(props: Draft<RectangleProps>, bounds: RectangleProps): void;

// @internal (undocumented)
export const ShowWidgetIconContext: React.Context<boolean>;

// @internal (undocumented)
export class ShrinkBottom extends ShrinkVerticalStrategy {
    // (undocumented)
    getDistanceToRoot(bounds: RectangleProps): number;
    // (undocumented)
    getDistanceToZoneToShrink(zoneId: WidgetZoneId, zoneToShrinkId: WidgetZoneId, props: ZonesManagerProps): number;
    // (undocumented)
    getShrinkStrategy(): UpdateWindowResizeSettings;
    // (undocumented)
    getZonesToShrink(zoneId: WidgetZoneId, props: ZonesManagerProps): WidgetZoneId[];
    // (undocumented)
    resize(bounds: RectangleProps, shrinkBy: number, moveBy: number): RectangleProps;
}

// @internal (undocumented)
export abstract class ShrinkHorizontalStrategy extends ShrinkStrategy {
    // (undocumented)
    getCurrentSize(bounds: RectangleProps): number;
    // (undocumented)
    getMinSize(): number;
}

// @internal (undocumented)
export class ShrinkLeft extends ShrinkHorizontalStrategy {
    // (undocumented)
    getDistanceToRoot(bounds: RectangleProps, zonesBounds: RectangleProps): number;
    // (undocumented)
    getDistanceToZoneToShrink(zoneId: WidgetZoneId, zoneToShrinkId: WidgetZoneId, props: ZonesManagerProps): number;
    // (undocumented)
    getShrinkStrategy(): UpdateWindowResizeSettings;
    // (undocumented)
    getZonesToShrink(zoneId: WidgetZoneId, props: ZonesManagerProps): WidgetZoneId[];
    // (undocumented)
    resize(bounds: RectangleProps, shrinkBy: number, moveBy: number): RectangleProps;
}

// @internal (undocumented)
export class ShrinkRight extends ShrinkHorizontalStrategy {
    // (undocumented)
    getDistanceToRoot(bounds: RectangleProps): number;
    // (undocumented)
    getDistanceToZoneToShrink(zoneId: WidgetZoneId, zoneToShrinkId: WidgetZoneId, props: ZonesManagerProps): number;
    // (undocumented)
    getShrinkStrategy(): UpdateWindowResizeSettings;
    // (undocumented)
    getZonesToShrink(zoneId: WidgetZoneId, props: ZonesManagerProps): WidgetZoneId[];
    // (undocumented)
    resize(bounds: RectangleProps, shrinkBy: number, moveBy: number): RectangleProps;
}

// @internal (undocumented)
export abstract class ShrinkStrategy implements ResizeStrategy {
    constructor(manager: ZonesManager);
    // (undocumented)
    abstract getCurrentSize(bounds: RectangleProps): number;
    // (undocumented)
    abstract getDistanceToRoot(bounds: RectangleProps, zonesBounds: RectangleProps): number;
    // (undocumented)
    abstract getDistanceToZoneToShrink(zoneId: WidgetZoneId, zoneToShrinkId: WidgetZoneId, props: ZonesManagerProps): number;
    // (undocumented)
    getMaxResize(zoneId: WidgetZoneId, props: ZonesManagerProps): number;
    // (undocumented)
    getMaxShrinkSelfBy(bounds: RectangleProps): number;
    // (undocumented)
    abstract getMinSize(): number;
    // (undocumented)
    abstract getShrinkStrategy(): ResizeStrategy;
    // (undocumented)
    abstract getZonesToShrink(zoneId: WidgetZoneId, props: ZonesManagerProps): WidgetZoneId[];
    // (undocumented)
    readonly manager: ZonesManager;
    // (undocumented)
    abstract resize(bounds: RectangleProps, shrinkBy: number, moveBy: number): RectangleProps;
    // (undocumented)
    tryResize(zoneId: WidgetZoneId, resizeBy: number, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    tryResizeFloating(zoneId: WidgetZoneId, resizeBy: number, props: ZonesManagerProps): {
        zones: {
            1: import("./Zone").ZoneManagerProps;
            2: import("./Zone").ZoneManagerProps;
            3: import("./Zone").ZoneManagerProps;
            4: import("./Zone").ZoneManagerProps;
            6: import("./Zone").ZoneManagerProps;
            7: import("./Zone").ZoneManagerProps;
            8: import("./Zone").ZoneManagerProps;
            9: import("./Zone").ZoneManagerProps;
        };
        draggedWidget?: import("./Widget").DraggedWidgetManagerProps | undefined;
        isInFooterMode: boolean;
        target?: import("./Zones").ZonesManagerTargetProps | undefined;
        widgets: import("./Zones").ZonesManagerWidgetsProps;
        zonesBounds: RectangleProps;
        floatingZonesBounds?: RectangleProps | undefined;
    };
}

// @internal (undocumented)
export class ShrinkTop extends ShrinkVerticalStrategy {
    // (undocumented)
    getDistanceToRoot(bounds: RectangleProps, zonesBounds: RectangleProps): number;
    // (undocumented)
    getDistanceToZoneToShrink(zoneId: WidgetZoneId, zoneToShrinkId: WidgetZoneId, props: ZonesManagerProps): number;
    // (undocumented)
    getShrinkStrategy(): UpdateWindowResizeSettings;
    // (undocumented)
    getZonesToShrink(zoneId: WidgetZoneId, props: ZonesManagerProps): WidgetZoneId[];
    // (undocumented)
    resize(bounds: RectangleProps, shrinkBy: number, moveBy: number): RectangleProps;
}

// @internal (undocumented)
export abstract class ShrinkVerticalStrategy extends ShrinkStrategy {
    // (undocumented)
    getCurrentSize(bounds: RectangleProps): number;
    // (undocumented)
    getMinSize(): number;
}

// @internal (undocumented)
export function sideToCursorType(side: PanelSide): CursorType;

// @internal
export interface SizeAndPositionProps extends SizeProps, PointProps {
}

// @internal
export class Snap extends React.PureComponent<SnapProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal @deprecated
export class SnapMode extends React.PureComponent<SnapModeProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export class SnapModePanel extends React.PureComponent<SnapModePanelProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface SnapModePanelProps extends CommonProps {
    children?: React.ReactNode;
    title?: string;
}

// @internal
export interface SnapModeProps extends FooterIndicatorProps {
    children?: string;
    icon?: React.ReactNode;
    indicatorRef?: React.Ref<HTMLDivElement>;
    onClick?: () => void;
}

// @internal
export interface SnapProps extends CommonProps {
    children?: string;
    icon?: React.ReactNode;
    isActive?: boolean;
    onClick?: () => void;
}

// @internal
export class Splitter extends React.PureComponent<SplitterProps, SplitterState> {
    constructor(props: SplitterProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(prevProps: SplitterProps): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    render(): JSX.Element;
    }

// @internal
export class SplitterPaneTarget extends React.PureComponent<MergeTargetProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface SplitterProps extends CommonProps {
    children?: React.ReactNode;
    isGripHidden?: boolean;
    isVertical?: boolean;
}

// @internal
export class SplitterTarget extends React.PureComponent<SplitterTargetProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface SplitterTargetProps extends MergeTargetProps {
    readonly isVertical?: boolean;
    readonly paneCount: number;
}

// @internal
export class Stacked extends React.PureComponent<StackedProps> {
    // (undocumented)
    getBounds(): RectangleProps;
    // (undocumented)
    render(): JSX.Element;
    }

// @internal
export interface StackedProps extends CommonProps, NoChildrenProps {
    content?: React.ReactNode;
    contentRef?: React.Ref<HTMLDivElement>;
    disabledResizeHandles?: DisabledResizeHandles;
    fillZone?: boolean;
    horizontalAnchor: HorizontalAnchor;
    isCollapsed?: boolean;
    isDragged?: boolean;
    isFloating?: boolean;
    isOpen?: boolean;
    isTabBarVisible?: boolean;
    onMouseEnter?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
    onMouseLeave?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
    onResize?: (resizeBy: number, handle: ResizeHandle, filledHeightDiff: number) => void;
    tabs?: React.ReactNode;
    verticalAnchor: VerticalAnchor;
}

// @internal
export class StagePanel extends React.PureComponent<StagePanelProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export class StagePanelManager {
    // (undocumented)
    get collapseOffset(): number;
    set collapseOffset(offset: number);
    // (undocumented)
    get maxSize(): number;
    set maxSize(size: number);
    // (undocumented)
    get minSize(): number;
    set minSize(size: number);
    // (undocumented)
    resize<TProps extends StagePanelManagerProps>(resizeBy: number, props: TProps): TProps;
    // (undocumented)
    setIsCollapsed<TProps extends StagePanelManagerProps>(isCollapsed: boolean, props: TProps): TProps;
    // (undocumented)
    setSize<TProps extends StagePanelManagerProps>(newSize: number, props: TProps): TProps;
    // (undocumented)
    shouldCollapse(resizeBy: number, props: StagePanelManagerProps): boolean;
}

// @internal
export interface StagePanelManagerProps {
    // (undocumented)
    readonly isCollapsed: boolean;
    // (undocumented)
    readonly size: number | undefined;
}

// @internal
export interface StagePanelProps extends CommonProps {
    children?: React.ReactNode;
    onResize?: (resizeBy: number) => void;
    onToggleCollapse?: () => void;
    safeAreaInsets?: SafeAreaInsets;
    size?: number;
    type: StagePanelType;
}

// @internal
export class StagePanels extends React.PureComponent<StagePanelsProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export class StagePanelsManager {
    // (undocumented)
    static getPanel<TProps extends StagePanelsManagerProps, T extends StagePanelType>(type: T, props: TProps): TProps[StagePanelTypeToPropName[T]];
    // (undocumented)
    getPanelManager(type: StagePanelType): StagePanelManager;
    // (undocumented)
    static getPanelPropName<T extends StagePanelType>(type: T): StagePanelTypeToPropName[T];
    // (undocumented)
    static getPanelType<T extends StagePanelPropNames>(propName: T): StagePanelPropNameToType[T];
    // (undocumented)
    resize<TProps extends StagePanelsManagerProps>(type: StagePanelType, resizeBy: number, props: TProps): TProps;
    // (undocumented)
    setIsCollapsed<TProps extends StagePanelsManagerProps>(type: StagePanelType, isCollapsed: boolean, props: TProps): TProps;
    // (undocumented)
    setSize<TProps extends StagePanelsManagerProps>(type: StagePanelType, size: number, props: TProps): TProps;
}

// @internal
export interface StagePanelsManagerProps {
    // (undocumented)
    readonly bottom: StagePanelManagerProps;
    // (undocumented)
    readonly left: StagePanelManagerProps;
    // (undocumented)
    readonly right: StagePanelManagerProps;
    // (undocumented)
    readonly top: StagePanelManagerProps;
}

// @internal
export interface StagePanelsProps extends CommonProps {
    bottomPanel?: React.ReactNode;
    children?: React.ReactNode;
    leftPanel?: React.ReactNode;
    rightPanel?: React.ReactNode;
    topPanel?: React.ReactNode;
}

// @internal
export class StagePanelTarget extends React.PureComponent<StagePanelTargetProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface StagePanelTargetProps extends MergeTargetProps {
    safeAreaInsets?: SafeAreaInsets;
    type: StagePanelType;
}

// @internal
export enum StagePanelType {
    // (undocumented)
    Bottom = 0,
    // (undocumented)
    Left = 1,
    // (undocumented)
    Right = 3,
    // (undocumented)
    Top = 2
}

// @internal
export class StagePanelTypeHelpers {
    // (undocumented)
    static getCssClassName(type: StagePanelType): string;
    static isVertical(type: StagePanelType): boolean;
}

// @internal
export enum Status {
    // (undocumented)
    Error = 2,
    // (undocumented)
    Information = 0,
    // (undocumented)
    Success = 1,
    // (undocumented)
    Warning = 3
}

// @internal
export class StatusHelpers {
    static readonly ERROR_CLASS_NAME = "nz-status-error";
    // (undocumented)
    static getCssClassName(status: Status): string;
    static readonly INFORMATION_CLASS_NAME = "nz-status-information";
    static readonly SUCCESS_CLASS_NAME = "nz-status-success";
    static readonly WARNING_CLASS_NAME = "nz-status-warning";
}

// @internal
export interface StatusMessageProps extends CommonProps {
    children?: React.ReactNode;
    icon?: React.ReactNode;
    status: Status;
}

// @internal
export class Tab extends React.PureComponent<TabProps> {
    // (undocumented)
    static defaultProps: TabDefaultProps;
    // (undocumented)
    getBounds(): RectangleProps;
    // (undocumented)
    render(): JSX.Element;
    }

// @internal (undocumented)
export const TabBarButtons: React.NamedExoticComponent<object>;

// @internal
export class TabGroup extends React.PureComponent<TabGroupProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface TabGroupProps extends CommonProps {
    children?: React.ReactNode;
    handle: HandleMode;
    horizontalAnchor: HorizontalAnchor;
    isCollapsed?: boolean;
    verticalAnchor: VerticalAnchor;
}

// @internal (undocumented)
export const TabIdContext: React.Context<string>;

// @internal
export enum TabMode {
    // (undocumented)
    Active = 2,
    // (undocumented)
    Closed = 0,
    // (undocumented)
    Open = 1
}

// @internal
export class TabModeHelpers {
    static readonly ACTIVE_CLASS_NAME = "nz-mode-active";
    static readonly CLOSED_CLASS_NAME = "nz-mode-closed";
    // (undocumented)
    static getCssClassName(mode: TabMode): string;
    static readonly OPEN_CLASS_NAME = "nz-mode-open";
}

// @internal (undocumented)
export const TabNodeContext: React.Context<React.ReactNode>;

// @internal (undocumented)
export const TabPositionContext: React.Context<TabPositionContextArgs>;

// @internal (undocumented)
export interface TabPositionContextArgs {
    // (undocumented)
    first?: boolean;
    // (undocumented)
    firstInactive?: boolean;
    // (undocumented)
    last?: boolean;
}

// @internal
export interface TabProps extends CommonProps {
    badge?: React.ReactNode;
    children?: React.ReactNode;
    horizontalAnchor: HorizontalAnchor;
    isCollapsed?: boolean;
    isProtruding: boolean;
    lastPosition?: PointProps;
    mode: TabMode;
    onClick?: () => void;
    onDrag?: (dragged: PointProps) => void;
    onDragEnd?: () => void;
    onDragStart?: (initialPosition: PointProps) => void;
    title?: string;
    verticalAnchor: VerticalAnchor;
}

// @internal
export class TabSeparator extends React.PureComponent<TabSeparatorProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface TabSeparatorProps extends CommonProps, NoChildrenProps {
    // (undocumented)
    readonly isHorizontal?: boolean;
}

// @internal
export interface TabsState {
    // (undocumented)
    readonly [id: string]: TabState;
}

// @internal (undocumented)
export const TabsStateContext: React.Context<TabsState>;

// @internal
export interface TabState {
    // (undocumented)
    readonly allowedPanelTargets?: PanelSide[];
    // (undocumented)
    readonly canPopout?: boolean;
    // (undocumented)
    readonly iconSpec?: IconSpec;
    // (undocumented)
    readonly id: string;
    // (undocumented)
    readonly isFloatingStateWindowResizable?: boolean;
    // (undocumented)
    readonly label: string;
    // (undocumented)
    readonly preferredFloatingWidgetSize?: SizeProps;
    // (undocumented)
    readonly preferredPanelWidgetSize?: "fit-content";
    // (undocumented)
    readonly preferredPopoutWidgetSize?: SizeAndPositionProps;
    // (undocumented)
    readonly userSized?: boolean;
}

// @internal (undocumented)
export const TabStateContext: React.Context<TabState>;

// @internal
export interface TabTargetFloatingWidgetState {
    // (undocumented)
    readonly newFloatingWidgetId: FloatingWidgetState["id"];
    // (undocumented)
    readonly size: SizeProps;
    // (undocumented)
    readonly type: "floatingWidget";
}

// @internal
export interface TabTargetPanelState {
    // (undocumented)
    readonly newWidgetId: WidgetState["id"];
    // (undocumented)
    readonly side: PanelSide;
    // (undocumented)
    readonly type: "panel";
}

// @internal
export type TabTargetState = TabTargetPanelState | TabTargetWidgetState | TabTargetTabState | TabTargetFloatingWidgetState;

// @internal
export interface TabTargetTabState {
    // (undocumented)
    readonly tabIndex: number;
    // (undocumented)
    readonly type: "tab";
    // (undocumented)
    readonly widgetId: WidgetState["id"];
}

// @internal
export interface TabTargetWidgetState {
    // (undocumented)
    readonly newWidgetId: WidgetState["id"];
    // (undocumented)
    readonly side: PanelSide;
    // (undocumented)
    readonly type: "widget";
    // (undocumented)
    readonly widgetIndex: number;
}

// @internal
export class Title extends React.PureComponent<TitleProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @beta
export class TitleBar extends React.PureComponent<TitleBarProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export class TitleBarButton extends React.PureComponent<TitleBarButtonProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface TitleBarButtonProps extends CommonProps {
    children?: React.ReactNode;
    onClick?: () => void;
    title?: string;
}

// @beta
export interface TitleBarProps extends CommonProps {
    children?: React.ReactNode;
    title?: string;
}

// @internal
export interface TitleProps extends CommonProps {
    children?: React.ReactNode;
}

// @internal @deprecated
export class Toast extends React.PureComponent<ToastProps, ToastState> {
    constructor(props: ToastProps);
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentWillUnmount(): void;
    // (undocumented)
    static readonly defaultProps: ToastDefaultProps;
    // (undocumented)
    render(): JSX.Element;
    }

// @internal
export type ToastDefaultProps = Pick<ToastProps, "timeout">;

// @internal
export interface ToastProps extends CommonProps, NoChildrenProps {
    animateOutTo?: HTMLElement | null;
    content?: React.ReactNode;
    onAnimatedOut?: () => void;
    timeout: number;
}

// @internal
export type ToastStyle = Pick<React.CSSProperties, "width" | "height">;

// @internal
export class ToolAssistance extends React.PureComponent<ToolAssistanceProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export class ToolAssistanceDialog extends React.PureComponent<ToolAssistanceDialogProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface ToolAssistanceDialogProps extends CommonProps {
    buttons?: React.ReactNode;
    children?: React.ReactNode;
    title?: string;
}

// @internal
export class ToolAssistanceInstruction extends React.PureComponent<ToolAssistanceInstructionProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface ToolAssistanceInstructionProps extends CommonProps {
    image: React.ReactNode;
    isNew?: boolean;
    text: string;
}

// @internal
export class ToolAssistanceItem extends React.PureComponent<ToolAssistanceItemProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface ToolAssistanceItemProps extends CommonProps {
    children?: React.ReactNode;
}

// @internal
export interface ToolAssistanceProps extends FooterIndicatorProps {
    children?: string;
    icons?: React.ReactNode;
    indicatorRef?: React.Ref<HTMLDivElement>;
    onClick?: () => void;
}

// @internal
export class ToolAssistanceSeparator extends React.PureComponent<ToolAssistanceSeparatorProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface ToolAssistanceSeparatorProps extends CommonProps {
    children?: string;
}

// @beta @deprecated
export class Toolbar extends React.PureComponent<ToolbarProps, ToolbarState> {
    // (undocumented)
    static readonly defaultProps: {
        expandsTo: Direction;
        panelAlignment: ToolbarPanelAlignment;
    };
    // (undocumented)
    render(): JSX.Element;
    // @internal (undocumented)
    readonly state: {
        panels: null;
    };
}

// @internal
export class ToolbarButton extends React.PureComponent<ToolbarButtonProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface ToolbarButtonProps extends CommonProps {
    children?: React.ReactNode;
    mouseProximity?: number;
    onClick?: () => void;
    small?: boolean;
    title?: string;
}

// @internal
export const ToolbarDirectionContext: React.Context<Direction>;

// @internal
export class ToolbarIcon extends React.PureComponent<ToolbarIconProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface ToolbarIconProps extends ToolbarButtonProps {
    icon?: React.ReactNode;
    mouseProximity?: number;
    small?: boolean;
}

// @internal
export interface ToolbarItem {
    // (undocumented)
    readonly panel: HTMLElement;
}

// @internal
export interface ToolbarItemProps<TItem extends ToolbarItem = ToolbarItem> {
    // (undocumented)
    readonly toolbarItemRef?: React.Ref<TItem>;
}

// @beta @deprecated
export enum ToolbarPanelAlignment {
    // (undocumented)
    End = 1,
    // (undocumented)
    Start = 0
}

// @internal
export class ToolbarPanelAlignmentHelpers {
    static readonly END_CLASS_NAME = "nz-panel-alignment-end";
    // (undocumented)
    static getCssClassName(panelAlignment: ToolbarPanelAlignment): string;
    static readonly START_CLASS_NAME = "nz-panel-alignment-start";
}

// @beta @deprecated
export interface ToolbarProps extends CommonProps, NoChildrenProps {
    expandsTo?: Direction;
    items?: React.ReactNode;
    panelAlignment?: ToolbarPanelAlignment;
}

// @internal
export class Tools extends React.PureComponent<ToolsProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export class ToolsArea extends React.PureComponent<ToolsAreaProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export interface ToolsAreaProps extends CommonProps, NoChildrenProps {
    button?: React.ReactNode;
    horizontalToolbar?: React.ReactNode;
    onMouseEnter?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
    onMouseLeave?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
    verticalToolbar?: React.ReactNode;
}

// @internal
export interface ToolSettingProps extends CommonProps {
    children?: React.ReactNode;
}

// @internal
export class ToolSettings extends React.PureComponent<ToolSettingsProps> {
    // (undocumented)
    getBounds(): RectangleProps;
    // (undocumented)
    render(): JSX.Element;
    }

// @internal
export interface ToolSettingsDockAction {
    // (undocumented)
    readonly type: "TOOL_SETTINGS_DOCK";
}

// @internal
export interface ToolSettingsDragStartAction {
    // (undocumented)
    readonly newFloatingWidgetId: FloatingWidgetState["id"];
    // (undocumented)
    readonly type: "TOOL_SETTINGS_DRAG_START";
}

// @internal (undocumented)
export const ToolSettingsNodeContext: React.Context<React.ReactNode>;

// @internal
export function ToolSettingsOverflowPanel(props: ToolSettingsOverflowPanelProps): JSX.Element;

// @internal
export interface ToolSettingsOverflowPanelProps extends CommonProps {
    children?: React.ReactNode;
    // (undocumented)
    onClose: () => void;
    // (undocumented)
    open: boolean;
    // (undocumented)
    target: HTMLElement | undefined;
}

// @internal
export interface ToolSettingsProps extends CommonProps {
    buttons?: React.ReactNode;
    children?: React.ReactNode;
    contentRef?: React.Ref<HTMLDivElement>;
    fillZone?: boolean;
    lastPosition?: PointProps;
    onDrag?: (dragged: PointProps) => void;
    onDragEnd?: () => void;
    onDragStart?: (initialPosition: PointProps) => void;
    onMouseEnter?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
    onMouseLeave?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
    onResize?: (resizeBy: number, handle: ResizeHandle) => void;
    title?: string;
}

// @internal
export type ToolSettingsState = DockedToolSettingsState | WidgetToolSettingsState;

// @internal (undocumented)
export const ToolSettingsStateContext: React.Context<ToolSettingsState>;

// @internal
export class ToolSettingsTab extends React.PureComponent<ToolSettingsTabProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal (undocumented)
export const toolSettingsTabId = "nz-tool-settings-tab";

// @internal
export interface ToolSettingsTabProps extends CommonProps {
    children?: React.ReactNode;
    onClick?: () => void;
    onKeyDown?: (e: React.KeyboardEvent) => void;
    onMouseEnter?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
    onMouseLeave?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
    title?: string;
}

// @internal
export interface ToolSettingsWidgetManagerProps extends WidgetManagerProps {
    // (undocumented)
    readonly mode: ToolSettingsWidgetMode;
}

// @internal
export enum ToolSettingsWidgetMode {
    // (undocumented)
    Tab = 0,
    // (undocumented)
    TitleBar = 1
}

// @internal
export interface ToolsProps extends CommonProps, NoChildrenProps {
    button?: React.ReactNode;
    horizontalToolbar?: React.ReactNode;
    isNavigation?: boolean;
    onMouseEnter?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
    onMouseLeave?: (event: React.MouseEvent<HTMLElement, MouseEvent>) => void;
    preserveSpace?: boolean;
    verticalToolbar?: React.ReactNode;
}

// @beta @deprecated
export class Tooltip extends React.PureComponent<TooltipProps> {
    // (undocumented)
    componentDidMount(): void;
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    static readonly defaultProps: TooltipDefaultProps;
    // (undocumented)
    render(): JSX.Element;
    }

// @beta @deprecated
export type TooltipDefaultProps = Pick<TooltipProps, "position">;

// @beta @deprecated
export interface TooltipProps extends CommonProps {
    children?: React.ReactNode;
    icon?: React.ReactNode;
    onSizeChanged?: (size: SizeProps) => void;
    position: PointProps;
}

// @internal (undocumented)
export type TopPanelSide = "top";

// @internal (undocumented)
export class UpdateWindowResizeSettings implements ResizeStrategy {
    constructor(manager: ZonesManager, resizeStrategy: ResizeStrategy);
    // (undocumented)
    getMaxResize(zoneId: WidgetZoneId, props: ZonesManagerProps): number;
    // (undocumented)
    readonly manager: ZonesManager;
    // (undocumented)
    readonly resizeStrategy: ResizeStrategy;
    // (undocumented)
    tryResize(zoneId: WidgetZoneId, resizeBy: number, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    tryResizeFloating(zoneId: WidgetZoneId, resizeBy: number, props: ZonesManagerProps): ZonesManagerProps;
}

// @internal (undocumented)
export function useActiveTab(): TabState | undefined;

// @internal (undocumented)
export function useAllowedPanelTarget(): boolean;

// @internal (undocumented)
export function useAnimatePanelWidgets(): {
    handleBeforeTransition: PanelWidgetProps["onBeforeTransition"];
    handlePrepareTransition: PanelWidgetProps["onPrepareTransition"];
    handleTransitionEnd: PanelWidgetProps["onTransitionEnd"];
    getRef(widgetId: WidgetState["id"]): React.Ref<WidgetComponent>;
    transition: PanelWidgetProps["transition"];
    sizes: {
        [id: string]: PanelWidgetProps["size"];
    };
};

// @internal (undocumented)
export function useBorders(widgetId: WidgetState["id"]): {
    "nz-border-top": boolean;
    "nz-border-bottom": boolean;
    "nz-border-left": boolean;
    "nz-border-right": boolean;
};

// @internal
export function useCursor(): void;

// @internal (undocumented)
export function useDoubleClick(onDoubleClick?: () => void): () => void;

// @internal
export function useDrag<T extends HTMLElement>(onDragStart?: (initialPointerPosition: Point) => void, onDrag?: (position: Point) => void, onDragEnd?: () => void, onTouchStart?: () => void, onDoubleClick?: () => void): (instance: T | null) => void;

// @internal (undocumented)
export function useDraggedItemId<T extends DragItem>(type: T["type"]): T["id"] | undefined;

// @internal (undocumented)
export function useDragItem<T extends DragItem>(args: UseDragItemArgs<T>): (info: DragItemInfo) => void;

// @internal (undocumented)
export interface UseDragItemArgs<T extends DragItem> {
    // (undocumented)
    isDragItem?: (item: T | undefined, dragged: DragItem) => boolean;
    // (undocumented)
    item: T;
    // (undocumented)
    onDrag?: DragEventHandler;
    // (undocumented)
    onDragEnd?: DragEventHandler;
    // (undocumented)
    onDragStart?: DragEventHandler;
}

// @internal (undocumented)
export function useDragPanelGrip(args: UseDragPanelGripArgs): ({ initialPointerPosition }: DragItemDragStartArgs) => void;

// @internal (undocumented)
export interface UseDragPanelGripArgs {
    // (undocumented)
    onDrag?: (pointerPosition: Point, lastPointerPosition: Point) => void;
    // (undocumented)
    onDragEnd?: () => void;
    // (undocumented)
    side: PanelSide;
}

// @internal (undocumented)
export function useDragResizeHandle(args: UseDragResizeHandleArgs): ({ initialPointerPosition }: DragItemDragStartArgs) => void;

// @internal (undocumented)
export interface UseDragResizeHandleArgs {
    // (undocumented)
    handle: FloatingWidgetResizeHandle;
    // (undocumented)
    onDrag?: (pointerPosition: Point) => void;
    // (undocumented)
    widgetId: WidgetState["id"];
}

// @internal (undocumented)
export function useDragTab(args: UseDragTabArgs): ({ initialPointerPosition, widgetSize }: DragTabDragStartArgs) => void;

// @internal (undocumented)
export interface UseDragTabArgs {
    // (undocumented)
    onDrag?: (dragBy: PointProps) => void;
    // (undocumented)
    onDragEnd?: (target: DragTarget | undefined, widgetSize: SizeProps) => void;
    // (undocumented)
    tabId: TabState["id"];
}

// @internal (undocumented)
export function useDragToolSettings(args: UseDragToolSettingsArgs): ({ initialPointerPosition }: DragItemDragStartArgs) => void;

// @internal (undocumented)
export interface UseDragToolSettingsArgs {
    // (undocumented)
    newWidgetDragItemId: WidgetDragItem["id"];
}

// @internal (undocumented)
export function useDragWidget(args: UseDragWidgetArgs): ({ initialPointerPosition }: DragItemDragStartArgs) => void;

// @internal (undocumented)
export interface UseDragWidgetArgs {
    // (undocumented)
    onDrag?: (dragBy: PointProps) => void;
    // (undocumented)
    onDragEnd?: (target: DragTarget | undefined) => void;
    // (undocumented)
    onDragStart?: (updateWidgetId: UpdateWidgetDragItemFn, initialPointerPosition: PointProps) => void;
    // (undocumented)
    widgetId: WidgetState["id"];
}

// @internal (undocumented)
export function useIsDragged(callback: () => boolean): boolean;

// @internal (undocumented)
export function useIsDraggedItem(item: DragItem): boolean;

// @internal (undocumented)
export function useIsDraggedType(type: DragItem["type"]): boolean;

// @internal (undocumented)
export function useIsMainPanelWidget(): boolean;

// @internal (undocumented)
export function useLabel(labelKey: keyof NineZoneLabels): string | undefined;

// @internal (undocumented)
export function useMode(widgetId: string): "fit" | "fill" | "minimized";

// @internal
export function useOverflow(children: React.ReactNode, activeChildIndex?: number): [
    ReadonlyArray<string> | undefined,
    (size: number) => void,
    (size: number) => void,
    (key: string) => (size: number) => void
];

// @internal (undocumented)
export function usePanelsAutoCollapse<T extends Element>(): React.Ref<T>;

// @internal (undocumented)
export function usePanelTarget<T extends Element>(args: UsePanelTargetArgs): [
    React.Ref<T>,
    boolean
];

// @internal (undocumented)
export interface UsePanelTargetArgs {
    // (undocumented)
    side: PanelSide;
}

// @internal
export const usePointerCaptor: <T extends HTMLElement>(onPointerDown?: ((args: PointerCaptorArgs, e: PointerCaptorEvent) => void) | undefined, onPointerMove?: ((args: PointerCaptorArgs, e: PointerCaptorEvent) => void) | undefined, onPointerUp?: ((e: PointerCaptorEvent) => void) | undefined) => (instance: T | null) => void;

// @internal (undocumented)
export const useResizeGrip: <T extends HTMLElement>() => [(instance: T | null) => void, boolean, boolean];

// @beta @deprecated
export class UserProfile extends React.PureComponent<UserProfileProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @beta @deprecated
export interface UserProfileProps extends CommonProps {
    children?: string;
    color?: string;
    initials?: string;
    onClick?: () => void;
    safeAreaInsets?: SafeAreaInsets;
}

// @internal (undocumented)
export function useTabTarget<T extends Element>(args: UseTabTargetArgs): [
    React.Ref<T>,
    boolean
];

// @internal (undocumented)
export interface UseTabTargetArgs {
    // (undocumented)
    tabIndex: number;
    // (undocumented)
    widgetId: WidgetState["id"];
}

// @internal (undocumented)
export function useTabTransientState(tabId: string, onSave?: () => void, onRestore?: () => void): void;

// @internal (undocumented)
export function useToolSettingsEntry(): DockedToolSettingsEntryContextArgs;

// @internal (undocumented)
export function useTransientState(onSave?: () => void, onRestore?: () => void): void;

// @internal (undocumented)
export function useWidgetTarget<T extends Element>(args: UseWidgetTargetArgs): [
    React.Ref<T>,
    boolean
];

// @internal (undocumented)
export interface UseWidgetTargetArgs {
    // (undocumented)
    side: PanelSide;
    // (undocumented)
    widgetIndex: number;
}

// @internal
export enum VerticalAnchor {
    // (undocumented)
    Bottom = 0,
    // (undocumented)
    BottomPanel = 1,
    // (undocumented)
    Middle = 2,
    // (undocumented)
    TopPanel = 3
}

// @internal
export class VerticalAnchorHelpers {
    static readonly BOTTOM_CLASS_NAME = "nz-bottom-anchor";
    static readonly BOTTOM_PANEL_CLASS_NAME = "nz-bottom-panel-anchor";
    // (undocumented)
    static getCssClassName(anchor: VerticalAnchor): string;
    // (undocumented)
    static isHorizontal(anchor: VerticalAnchor): boolean;
    static readonly MIDDLE_CLASS_NAME = "nz-middle-anchor";
    static readonly TOP_PANEL_CLASS_NAME = "nz-top-panel-anchor";
}

// @internal (undocumented)
export type VerticalPanelSide = LeftPanelSide | RightPanelSide;

// @internal
export interface VerticalPanelState extends PanelState {
    // (undocumented)
    readonly side: VerticalPanelSide;
}

// @internal (undocumented)
export const Widget: React.MemoExoticComponent<React.ForwardRefExoticComponent<WidgetProps & React.RefAttributes<WidgetComponent>>>;

// @internal (undocumented)
export interface WidgetComponent {
    // (undocumented)
    measure: () => SizeProps;
}

// @alpha @deprecated
export class WidgetContent extends React.PureComponent<WidgetContentProps> {
    // (undocumented)
    componentDidUpdate(): void;
    // (undocumented)
    render(): JSX.Element;
    }

// @internal (undocumented)
export const WidgetContentContainer: React.NamedExoticComponent<object>;

// @internal (undocumented)
export const WidgetContentContainersContext: React.Context<WidgetContentContainers>;

// @internal (undocumented)
export const WidgetContentManager: React.NamedExoticComponent<WidgetContentManagerProps>;

// @internal (undocumented)
export const WidgetContentManagerContext: React.Context<WidgetContentManagerContextArgs>;

// @internal (undocumented)
export interface WidgetContentManagerContextArgs {
    // (undocumented)
    onRestoreTransientState: EventEmitter<(tabId: TabState["id"]) => void>;
    // (undocumented)
    onSaveTransientState: EventEmitter<(tabId: TabState["id"]) => void>;
    // (undocumented)
    setContainer(tabId: TabState["id"], container: Element | null): void;
}

// @internal (undocumented)
export interface WidgetContentManagerProps {
    // (undocumented)
    children?: React.ReactNode;
}

// @internal (undocumented)
export const WidgetContentNodeContext: React.Context<React.ReactNode>;

// @alpha @deprecated
export interface WidgetContentProps extends CommonProps, NoChildrenProps {
    anchor: HorizontalAnchor;
    containerRef?: React.Ref<HTMLDivElement>;
    content?: React.ReactNode;
}

// @internal (undocumented)
export const WidgetContentRenderer: React.NamedExoticComponent<WidgetContentRendererProps>;

// @internal (undocumented)
export const WidgetContentRenderers: React.NamedExoticComponent<object>;

// @internal (undocumented)
export const WidgetContext: React.Context<WidgetContextArgs>;

// @internal (undocumented)
export interface WidgetContextArgs {
    // (undocumented)
    measure: () => SizeProps;
}

// @internal
export interface WidgetDragAction {
    // (undocumented)
    readonly dragBy: PointProps;
    // (undocumented)
    readonly floatingWidgetId: FloatingWidgetState["id"];
    // (undocumented)
    readonly type: "WIDGET_DRAG";
}

// @internal
export interface WidgetDragEndAction {
    // (undocumented)
    readonly floatingWidgetId: FloatingWidgetState["id"];
    // (undocumented)
    readonly target: WidgetTargetState;
    // (undocumented)
    readonly type: "WIDGET_DRAG_END";
}

// @internal (undocumented)
export const WidgetIdContext: React.Context<string>;

// @internal
export interface WidgetManagerProps {
    // (undocumented)
    readonly horizontalAnchor: HorizontalAnchor;
    // (undocumented)
    readonly id: WidgetZoneId;
    // (undocumented)
    readonly tabIndex: number;
    // (undocumented)
    readonly verticalAnchor: VerticalAnchor;
}

// @internal (undocumented)
export function WidgetMenu(props: WidgetMenuProps): JSX.Element;

// @internal (undocumented)
export interface WidgetMenuProps extends CommonProps {
    // (undocumented)
    children?: React.ReactNode;
    // (undocumented)
    onClose?: () => void;
    // (undocumented)
    open?: boolean;
    // (undocumented)
    target?: HTMLElement;
}

// @internal (undocumented)
export const WidgetOverflow: React.NamedExoticComponent<WidgetOverflowProps>;

// @internal (undocumented)
export const WidgetOverflowContext: React.Context<WidgetOverflowContextArgs | undefined>;

// @internal (undocumented)
export interface WidgetOverflowProps {
    // (undocumented)
    children?: React.ReactNode;
    // (undocumented)
    hidden?: boolean;
    // (undocumented)
    onResize?: (w: number) => void;
}

// @internal (undocumented)
export const WidgetPanel: React.NamedExoticComponent<WidgetPanelProps>;

// @internal (undocumented)
export const WidgetPanelContext: React.Context<WidgetPanelContextArgs | undefined>;

// @internal (undocumented)
export interface WidgetPanelContextArgs {
    // (undocumented)
    getBounds(): RectangleProps;
}

// @internal
export function WidgetPanelExpander({ side }: WidgetPanelExpanderProps): JSX.Element;

// @internal (undocumented)
export interface WidgetPanelExpanderProps {
    // (undocumented)
    side: PanelSide;
}

// @internal (undocumented)
export function WidgetPanelExpanders(): JSX.Element;

// @internal
export const WidgetPanelGrip: React.NamedExoticComponent<CommonProps>;

// @internal (undocumented)
export interface WidgetPanelProps {
    // (undocumented)
    spanBottom?: boolean;
    // (undocumented)
    spanTop?: boolean;
}

// @internal
export const WidgetPanelProvider: React.NamedExoticComponent<WidgetPanelProviderProps>;

// @internal
export interface WidgetPanelProviderProps {
    // (undocumented)
    side: PanelSide;
}

// @internal
export const WidgetPanels: React.NamedExoticComponent<WidgetPanelsProps>;

// @internal
export const WidgetPanelsContent: React.MemoExoticComponent<React.ForwardRefExoticComponent<WidgetPanelsContentProps & React.RefAttributes<HTMLDivElement>>>;

// @internal
export interface WidgetPanelsContentProps extends CommonProps {
    // (undocumented)
    children?: React.ReactNode;
    // (undocumented)
    pinnedBottom?: boolean;
    // (undocumented)
    pinnedLeft?: boolean;
    // (undocumented)
    pinnedRight?: boolean;
    // (undocumented)
    pinnedTop?: boolean;
}

// @internal
export interface WidgetPanelsProps extends CommonProps {
    centerContent?: React.ReactNode;
    children?: React.ReactNode;
}

// @internal (undocumented)
export interface WidgetProps extends CommonProps {
    // (undocumented)
    children?: React.ReactNode;
    // (undocumented)
    onTransitionEnd?(): void;
    // (undocumented)
    widgetId?: string;
}

// @internal (undocumented)
export const WidgetProvider: React.NamedExoticComponent<WidgetProviderProps>;

// @internal (undocumented)
export interface WidgetProviderProps {
    // (undocumented)
    children?: React.ReactNode;
    // (undocumented)
    widget: WidgetState;
}

// @internal
export interface WidgetsState {
    // (undocumented)
    readonly [id: string]: WidgetState;
}

// @internal (undocumented)
export const WidgetsStateContext: React.Context<WidgetsState>;

// @internal
export interface WidgetState {
    // (undocumented)
    readonly activeTabId: TabState["id"];
    // (undocumented)
    readonly id: string;
    // (undocumented)
    readonly isFloatingStateWindowResizable?: boolean;
    // (undocumented)
    readonly minimized: boolean;
    // (undocumented)
    readonly tabs: ReadonlyArray<TabState["id"]>;
}

// @internal (undocumented)
export const WidgetStateContext: React.Context<WidgetState | undefined>;

// @internal
export const WidgetTab: React.NamedExoticComponent<WidgetTabProps>;

// @internal (undocumented)
export const WidgetTabBar: React.NamedExoticComponent<WidgetTabBarProps>;

// @internal (undocumented)
export interface WidgetTabBarProps {
    // (undocumented)
    separator?: boolean;
}

// @internal
export interface WidgetTabClickAction {
    // (undocumented)
    readonly id: TabState["id"];
    // (undocumented)
    readonly side: PanelSide | undefined;
    // (undocumented)
    readonly type: "WIDGET_TAB_CLICK";
    // (undocumented)
    readonly widgetId: WidgetState["id"];
}

// @internal
export interface WidgetTabDoubleClickAction {
    // (undocumented)
    readonly floatingWidgetId: FloatingWidgetState["id"] | undefined;
    // (undocumented)
    readonly id: TabState["id"];
    // (undocumented)
    readonly side: PanelSide | undefined;
    // (undocumented)
    readonly type: "WIDGET_TAB_DOUBLE_CLICK";
    // (undocumented)
    readonly widgetId: WidgetState["id"];
}

// @internal
export interface WidgetTabDragAction {
    // (undocumented)
    readonly dragBy: PointProps;
    // (undocumented)
    readonly type: "WIDGET_TAB_DRAG";
}

// @internal
export interface WidgetTabDragEndAction {
    // (undocumented)
    readonly id: TabState["id"];
    // (undocumented)
    readonly target: TabTargetState;
    // (undocumented)
    readonly type: "WIDGET_TAB_DRAG_END";
}

// @internal
export interface WidgetTabDragStartAction {
    // (undocumented)
    readonly floatingWidgetId: FloatingWidgetState["id"] | undefined;
    // (undocumented)
    readonly id: TabState["id"];
    // (undocumented)
    readonly position: PointProps;
    // (undocumented)
    readonly side: PanelSide | undefined;
    // (undocumented)
    readonly type: "WIDGET_TAB_DRAG_START";
    // (undocumented)
    readonly widgetId: WidgetState["id"];
}

// @internal
export interface WidgetTabDragStartArguments {
    readonly initialPosition: PointProps;
    readonly tabIndex: number;
    readonly widgetBounds: RectangleProps;
    readonly widgetId: WidgetZoneId;
}

// @internal
export interface WidgetTabPopoutAction {
    // (undocumented)
    readonly id: WidgetState["activeTabId"];
    // (undocumented)
    readonly type: "WIDGET_TAB_POPOUT";
}

// @internal
export interface WidgetTabProps extends CommonProps {
    // (undocumented)
    badge?: React.ReactNode;
}

// @internal (undocumented)
export function WidgetTabProvider({ tab, first, firstInactive, last, showOnlyTabIcon }: WidgetTabProviderProps): JSX.Element;

// @internal (undocumented)
export interface WidgetTabProviderProps extends TabPositionContextArgs {
    // (undocumented)
    showOnlyTabIcon?: boolean;
    // (undocumented)
    tab: TabState;
}

// @internal (undocumented)
export const WidgetTabs: React.NamedExoticComponent<object>;

// @internal (undocumented)
export const WidgetTabsEntryContext: React.Context<WidgetTabsEntryContextArgs | undefined>;

// @internal (undocumented)
export interface WidgetTabsEntryContextProviderProps {
    // (undocumented)
    children?: React.ReactNode;
    // (undocumented)
    getOnResize: (id: string) => (w: number) => void;
    // (undocumented)
    id: string;
    // (undocumented)
    lastNotOverflown: boolean;
}

// @internal (undocumented)
export const WidgetTabsEntryProvider: React.NamedExoticComponent<WidgetTabsEntryContextProviderProps>;

// @internal
export const WidgetTabTarget: React.NamedExoticComponent<WidgetTabTargetProps>;

// @internal (undocumented)
export interface WidgetTabTargetProps {
    // (undocumented)
    first?: boolean;
    // (undocumented)
    tabIndex: number;
}

// @internal (undocumented)
export const WidgetTarget: React.NamedExoticComponent<WidgetTargetProps>;

// @internal
export interface WidgetTargetFloatingWidgetState {
    // (undocumented)
    readonly type: "floatingWidget";
}

// @internal
export type WidgetTargetPanelState = TabTargetPanelState;

// @internal (undocumented)
export interface WidgetTargetProps {
    // (undocumented)
    position?: "first" | "last";
    // (undocumented)
    widgetIndex: number;
}

// @internal
export type WidgetTargetState = WidgetTargetPanelState | WidgetTargetWidgetState | WidgetTargetTabState | WidgetTargetFloatingWidgetState;

// @internal
export type WidgetTargetTabState = TabTargetTabState;

// @internal
export type WidgetTargetWidgetState = TabTargetWidgetState;

// @internal
export interface WidgetToolSettingsState {
    // (undocumented)
    readonly type: "widget";
}

// @internal (undocumented)
export const widgetZoneColumnIds: ReadonlyArray<WidgetZoneId>;

// @beta @deprecated
export type WidgetZoneId = 1 | 2 | 3 | 4 | 6 | 7 | 8 | 9;

// @internal
export const widgetZoneIds: ReadonlyArray<WidgetZoneId>;

// @alpha @deprecated
export const withContainIn: <ComponentProps extends {}>(Component: React.ComponentType<ComponentProps>) => {
    new (props: (ComponentProps & WithContainInProps) | Readonly<ComponentProps & WithContainInProps>): {
        ref: React.RefObject<HTMLDivElement>;
        readonly containFn: (componentBounds: RectangleProps, containerBounds: RectangleProps) => RectangleProps;
        getContainerBounds(): Rectangle;
        getComponentBounds(root: HTMLElement): Rectangle;
        componentDidMount(): void;
        render(): JSX.Element;
        context: any;
        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps & WithContainInProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
        forceUpdate(callback?: (() => void) | undefined): void;
        readonly props: Readonly<ComponentProps & WithContainInProps> & Readonly<{
            children?: React.ReactNode;
        }>;
        state: Readonly<{}>;
        refs: {
            [key: string]: React.ReactInstance;
        };
        shouldComponentUpdate?(nextProps: Readonly<ComponentProps & WithContainInProps>, nextState: Readonly<{}>, nextContext: any): boolean;
        componentWillUnmount?(): void;
        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps & WithContainInProps>, prevState: Readonly<{}>): any;
        componentDidUpdate?(prevProps: Readonly<ComponentProps & WithContainInProps>, prevState: Readonly<{}>, snapshot?: any): void;
        componentWillMount?(): void;
        UNSAFE_componentWillMount?(): void;
        componentWillReceiveProps?(nextProps: Readonly<ComponentProps & WithContainInProps>, nextContext: any): void;
        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps & WithContainInProps>, nextContext: any): void;
        componentWillUpdate?(nextProps: Readonly<ComponentProps & WithContainInProps>, nextState: Readonly<{}>, nextContext: any): void;
        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps & WithContainInProps>, nextState: Readonly<{}>, nextContext: any): void;
    };
    new (props: ComponentProps & WithContainInProps, context: any): {
        ref: React.RefObject<HTMLDivElement>;
        readonly containFn: (componentBounds: RectangleProps, containerBounds: RectangleProps) => RectangleProps;
        getContainerBounds(): Rectangle;
        getComponentBounds(root: HTMLElement): Rectangle;
        componentDidMount(): void;
        render(): JSX.Element;
        context: any;
        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<ComponentProps & WithContainInProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
        forceUpdate(callback?: (() => void) | undefined): void;
        readonly props: Readonly<ComponentProps & WithContainInProps> & Readonly<{
            children?: React.ReactNode;
        }>;
        state: Readonly<{}>;
        refs: {
            [key: string]: React.ReactInstance;
        };
        shouldComponentUpdate?(nextProps: Readonly<ComponentProps & WithContainInProps>, nextState: Readonly<{}>, nextContext: any): boolean;
        componentWillUnmount?(): void;
        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
        getSnapshotBeforeUpdate?(prevProps: Readonly<ComponentProps & WithContainInProps>, prevState: Readonly<{}>): any;
        componentDidUpdate?(prevProps: Readonly<ComponentProps & WithContainInProps>, prevState: Readonly<{}>, snapshot?: any): void;
        componentWillMount?(): void;
        UNSAFE_componentWillMount?(): void;
        componentWillReceiveProps?(nextProps: Readonly<ComponentProps & WithContainInProps>, nextContext: any): void;
        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<ComponentProps & WithContainInProps>, nextContext: any): void;
        componentWillUpdate?(nextProps: Readonly<ComponentProps & WithContainInProps>, nextState: Readonly<{}>, nextContext: any): void;
        UNSAFE_componentWillUpdate?(nextProps: Readonly<ComponentProps & WithContainInProps>, nextState: Readonly<{}>, nextContext: any): void;
    };
    contextType?: React.Context<any> | undefined;
};

// @alpha @deprecated
export interface WithContainInProps {
    container?: HTMLElement | null;
    containFn?: (componentBounds: RectangleProps, containerBounds: RectangleProps) => RectangleProps;
}

// @internal
export const withDragInteraction: <P extends {}, C>(Component: React.JSXElementConstructor<P> & C) => (props: JSX.LibraryManagedAttributes<C, P & WithDragInteractionProps>) => JSX.Element;

// @internal
export interface WithDragInteractionProps {
    direction: Direction;
    onClick?: () => void;
    onOpenPanel?: () => void;
}

// @internal
export class Zone extends React.PureComponent<ZoneProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export type ZoneId = WidgetZoneId | ContentZoneId;

// @internal
export class ZoneManager {
    constructor(windowResize?: ZoneWindowResizeSettings);
    // (undocumented)
    setAllowsMerging(allowsMerging: boolean, props: ZoneManagerProps): ZoneManagerProps;
    // (undocumented)
    setBounds(bounds: RectangleProps, props: ZoneManagerProps): ZoneManagerProps;
    // (undocumented)
    setFloatingBounds(bounds: RectangleProps, props: ZoneManagerProps): ZoneManagerProps;
    // (undocumented)
    setFloatingProps(floating: ZoneManagerFloatingProps | undefined, props: ZoneManagerProps): ZoneManagerProps;
    // (undocumented)
    setIsLayoutChanged(isLayoutChanged: boolean, props: ZoneManagerProps): ZoneManagerProps;
    // (undocumented)
    windowResize: ZoneWindowResizeSettings;
}

// @internal
export interface ZoneManagerFloatingProps {
    // (undocumented)
    readonly bounds: RectangleProps;
    // (undocumented)
    readonly stackId: number;
}

// @internal
export interface ZoneManagerProps {
    // (undocumented)
    readonly allowsMerging: boolean;
    // (undocumented)
    readonly bounds: RectangleProps;
    // (undocumented)
    readonly floating?: ZoneManagerFloatingProps;
    // (undocumented)
    readonly id: WidgetZoneId;
    // (undocumented)
    readonly isLayoutChanged: boolean;
    // (undocumented)
    readonly widgets: ReadonlyArray<WidgetZoneId>;
}

// @internal
export interface ZoneProps extends CommonProps {
    bounds?: RectangleProps;
    children?: React.ReactNode;
    id: WidgetZoneId;
    isFloating?: boolean;
    isHidden?: boolean;
    isInFooterMode?: boolean;
    safeAreaInsets?: SafeAreaInsets;
}

// @internal
export class Zones extends React.PureComponent<ZonesProps> {
    // (undocumented)
    render(): JSX.Element;
}

// @internal
export class ZonesManager {
    // (undocumented)
    addWidget(zoneId: WidgetZoneId, widgetId: WidgetZoneId, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    readonly bottomZones: BottomZones;
    // (undocumented)
    canBeMergedTo(zoneId: WidgetZoneId, targetZoneId: WidgetZoneId, props: ZonesManagerProps): boolean;
    // (undocumented)
    get draggedWidgetManager(): DraggedWidgetManager;
    // (undocumented)
    findZoneWithWidget(widgetId: WidgetZoneId, props: ZonesManagerProps): ZoneManagerProps | undefined;
    // (undocumented)
    getDisabledResizeHandles(zoneId: WidgetZoneId, props: ZonesManagerProps): DisabledResizeHandles;
    // (undocumented)
    getDropTarget(zoneId: WidgetZoneId, props: ZonesManagerProps): ZoneTargetType | undefined;
    // (undocumented)
    getGhostOutlineBounds(zoneId: WidgetZoneId, props: ZonesManagerProps): RectangleProps | undefined;
    // (undocumented)
    getInitialBounds(zoneId: WidgetZoneId, props: ZonesManagerProps): RectangleProps;
    // (undocumented)
    getResizeStrategy(handle: ResizeHandle, resizeBy: number): ResizeStrategy;
    // (undocumented)
    getUnmergeWidgetBounds(zoneId: WidgetZoneId, props: ZonesManagerProps): Array<{
        id: WidgetZoneId;
        bounds: RectangleProps;
    }>;
    // (undocumented)
    getWindowResizeBounds(props: ZonesManagerProps): {
        [id in WidgetZoneId]: RectangleProps;
    };
    // (undocumented)
    getZoneManager(id: WidgetZoneId): ZoneManager;
    // (undocumented)
    readonly growBottom: UpdateWindowResizeSettings;
    // (undocumented)
    readonly growLeft: UpdateWindowResizeSettings;
    // (undocumented)
    readonly growRight: UpdateWindowResizeSettings;
    // (undocumented)
    readonly growTop: UpdateWindowResizeSettings;
    // (undocumented)
    handleTargetChanged(target: ZonesManagerTargetProps | undefined, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    handleWidgetResize({ filledHeightDiff, handle, zoneId, resizeBy }: ZonesManagerWidgetResizeArgs, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    handleWidgetTabClick(widgetId: WidgetZoneId, tabIndex: number, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    handleWidgetTabDrag(dragged: PointProps, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    handleWidgetTabDragEnd(props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    handleWidgetTabDragStart(widgetId: WidgetZoneId, tabIndex: number, initialPosition: PointProps, widgetBounds: RectangleProps, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    isMergedHorizontally(zoneId: WidgetZoneId, props: ZonesManagerProps): boolean;
    // (undocumented)
    isMergedVertically(zoneId: WidgetZoneId, props: ZonesManagerProps): boolean;
    // (undocumented)
    isResizable(zoneId: WidgetZoneId): boolean;
    // (undocumented)
    isWidgetOpen(zoneId: WidgetZoneId, props: ZonesManagerProps): boolean;
    // (undocumented)
    readonly leftZones: LeftZones;
    // (undocumented)
    mergeZone(zoneId: WidgetZoneId, targetZoneId: WidgetZoneId, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    removeWidget(zoneId: WidgetZoneId, widgetId: WidgetZoneId, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    restoreLayout(props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    readonly rightZones: RightZones;
    // (undocumented)
    saveWindowSettings(id: WidgetZoneId, props: ZonesManagerProps): void;
    // (undocumented)
    setAllowsMerging(zoneId: WidgetZoneId, allowsMerging: boolean, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    setDraggedWidgetLastPosition(lastPosition: PointProps, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    setDraggedWidgetProps(draggedWidget: DraggedWidgetManagerProps | undefined, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    setFloatingZonesBounds(bounds: RectangleProps | undefined, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    setIsInFooterMode(isInFooterMode: boolean, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    setToolSettingsWidgetMode<TProps extends ZonesManagerProps>(mode: ToolSettingsWidgetMode, props: TProps): TProps;
    // (undocumented)
    setWidgetHorizontalAnchor<TProps extends ZonesManagerProps>(widgetId: WidgetZoneId, horizontalAnchor: HorizontalAnchor, props: TProps): TProps;
    // (undocumented)
    setWidgetTabIndex<TProps extends ZonesManagerProps>(widgetId: WidgetZoneId, tabIndex: number, props: TProps): TProps;
    // (undocumented)
    setWidgetVerticalAnchor<TProps extends ZonesManagerProps>(widgetId: WidgetZoneId, verticalAnchor: VerticalAnchor, props: TProps): TProps;
    // (undocumented)
    setZoneBounds(zoneId: WidgetZoneId, bounds: RectangleProps, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    setZoneFloatingBounds(zoneId: WidgetZoneId, bounds: RectangleProps, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    setZoneIsLayoutChanged(zoneId: WidgetZoneId, isLayoutChanged: boolean, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    setZoneProps(zoneProps: ZoneManagerProps, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    setZonesBounds(zonesBounds: RectangleProps, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    setZoneWidth(zoneId: WidgetZoneId, width: number, props: ZonesManagerProps): ZonesManagerProps;
    // (undocumented)
    readonly shrinkBottom: UpdateWindowResizeSettings;
    // (undocumented)
    readonly shrinkLeft: UpdateWindowResizeSettings;
    // (undocumented)
    readonly shrinkRight: UpdateWindowResizeSettings;
    // (undocumented)
    readonly shrinkTop: UpdateWindowResizeSettings;
    // (undocumented)
    readonly topZones: TopZones;
    }

// @internal
export interface ZonesManagerProps {
    // (undocumented)
    readonly draggedWidget?: DraggedWidgetManagerProps;
    // (undocumented)
    readonly floatingZonesBounds?: RectangleProps;
    // (undocumented)
    readonly isInFooterMode: boolean;
    // (undocumented)
    readonly target?: ZonesManagerTargetProps;
    // (undocumented)
    readonly widgets: ZonesManagerWidgetsProps;
    // (undocumented)
    readonly zones: ZonesManagerZonesProps;
    // (undocumented)
    readonly zonesBounds: RectangleProps;
}

// @internal
export interface ZonesManagerTargetProps {
    // (undocumented)
    readonly type: ZoneTargetType;
    // (undocumented)
    readonly zoneId: WidgetZoneId;
}

// @internal
export interface ZonesManagerWidgetResizeArgs {
    // (undocumented)
    readonly filledHeightDiff: number;
    // (undocumented)
    readonly handle: ResizeHandle;
    // (undocumented)
    readonly resizeBy: number;
    // (undocumented)
    readonly zoneId: WidgetZoneId;
}

// @internal
export type ZonesManagerWidgetsProps = {
    readonly [id in Exclude<WidgetZoneId, 2>]: WidgetManagerProps;
} & {
    readonly [2]: ToolSettingsWidgetManagerProps;
};

// @internal
export type ZonesManagerZonesProps = {
    readonly [id in WidgetZoneId]: ZoneManagerProps;
};

// @internal
export interface ZonesProps extends CommonProps {
    children?: React.ReactNode;
    isHidden?: boolean;
}

// @beta @deprecated
export enum ZoneTargetType {
    // (undocumented)
    Back = 1,
    // (undocumented)
    Merge = 2
}

// @internal (undocumented)
export interface ZoneWindowResizeSettings {
    // (undocumented)
    hEnd: number;
    // (undocumented)
    hMode: "Minimum" | "Percentage";
    // (undocumented)
    hStart: number;
    // (undocumented)
    minHeight: number;
    // (undocumented)
    minWidth: number;
    // (undocumented)
    vEnd: number;
    // (undocumented)
    vMode: "Minimum" | "Percentage";
    // (undocumented)
    vStart: number;
}


// (No @packageDocumentation comment for this package)