/*!
 * react-mosaic-ui — Copyright 2025-2026 HeoJeongBo — Apache-2.0
 * Derived from react-mosaic (https://github.com/nomcopter/react-mosaic),
 * Copyright 2019 Kevin Verdieck, originally developed at Palantir Technologies, Inc.
 * Modified for react-mosaic-ui — see NOTICE for the list of changes.
 */
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as react from 'react';
import react__default, { ReactNode, ComponentType } from 'react';

type MosaicKey = string | number;
type MosaicDirection = 'row' | 'column';
type MosaicBranch = 'first' | 'second';
type MosaicPath = MosaicBranch[];
type MosaicNode<T extends MosaicKey = string> = MosaicParent<T> | T;
interface MosaicParent<T extends MosaicKey = string> {
    direction: MosaicDirection;
    first: MosaicNode<T>;
    second: MosaicNode<T>;
    splitPercentage?: number;
}
declare enum MosaicDropTargetPosition {
    TOP = "TOP",
    BOTTOM = "BOTTOM",
    LEFT = "LEFT",
    RIGHT = "RIGHT"
}
declare enum Corner {
    TOP_LEFT = 1,
    TOP_RIGHT = 2,
    BOTTOM_LEFT = 3,
    BOTTOM_RIGHT = 4
}
interface ResizeOptions {
    minimumPaneSizePercentage?: number;
}
interface BoundingBox {
    top: number;
    right: number;
    bottom: number;
    left: number;
}
interface MosaicUpdate<T extends MosaicKey = string> {
    path: MosaicPath;
    spec: MosaicUpdateSpec<T>;
}
type MosaicUpdateSpec<T extends MosaicKey = string> = {
    $set: MosaicNode<T>;
} | {
    splitPercentage?: {
        $set: number;
    };
    direction?: {
        $set: MosaicDirection;
    };
    first?: MosaicUpdateSpec<T>;
    second?: MosaicUpdateSpec<T>;
};
interface MosaicDragItem {
    mosaicId: string;
    path: MosaicPath;
}
interface MosaicDropData {
    path: MosaicPath;
    position: MosaicDropTargetPosition;
}
type TileRenderer<T extends MosaicKey = string> = (id: T, path: MosaicPath) => react.ReactNode;
type CreateNode<T extends MosaicKey = string> = () => T | Promise<T>;
interface MosaicPanelConfig<TId extends MosaicKey = string> {
    id: TId;
    title: string;
    content: react.ReactNode;
    renderToolbar?: () => react.ReactNode;
    Wrapper?: react.ComponentType<{
        children: react.ReactNode;
    }>;
    closable?: boolean;
    hideToolbar?: boolean;
    bodyPadding?: string | number;
    bodyClassName?: string;
}
interface DragBindings {
    ref: (el: HTMLElement | null) => void;
}

interface MosaicRootActions<T extends MosaicKey = string> {
    expand: (path: MosaicPath, percentage?: number) => void;
    remove: (path: MosaicPath) => void;
    hide: (path: MosaicPath) => void;
    replaceWith: (path: MosaicPath, node: MosaicNode<T>) => void;
    updateTree: (updates: MosaicUpdate<T>[], suppressOnRelease?: boolean) => void;
    getRoot: () => MosaicNode<T> | null;
    add: (newNode: T, direction?: MosaicDirection) => void;
    maximize: (path: MosaicPath) => void;
    restore: () => void;
    isMaximized: () => boolean;
}
interface MosaicContextValue<T extends MosaicKey = string> {
    mosaicActions: MosaicRootActions<T>;
    mosaicId: string;
    renderTile: TileRenderer<T>;
}
interface MosaicWindowActions {
    split: () => Promise<void>;
    replaceWithNew: () => Promise<void>;
    getPath: () => MosaicPath;
}
interface MosaicWindowContextValue<T extends MosaicKey = string> {
    mosaicWindowActions: MosaicWindowActions;
    panelId?: T;
}

interface MosaicBaseProps<T extends MosaicKey> {
    renderTile: TileRenderer<T>;
    onChange?: (node: MosaicNode<T> | null) => void;
    onRelease?: (node: MosaicNode<T> | null) => void;
    className?: string;
    resize?: ResizeOptions;
    zeroStateView?: JSX.Element;
    mosaicId?: string;
    ariaLabel?: string;
    highlightActive?: boolean;
    children?: React.ReactNode;
}
interface MosaicControlledProps<T extends MosaicKey> extends MosaicBaseProps<T> {
    value: MosaicNode<T> | null;
    onChange: (node: MosaicNode<T> | null) => void;
}
interface MosaicUncontrolledProps<T extends MosaicKey> extends MosaicBaseProps<T> {
    initialValue: MosaicNode<T> | null;
}
type MosaicProps<T extends MosaicKey> = MosaicControlledProps<T> | MosaicUncontrolledProps<T>;
declare const Mosaic: <T extends MosaicKey>(props: MosaicProps<T>) => react_jsx_runtime.JSX.Element;

interface MosaicWindowProps<T extends MosaicKey> {
    title: string;
    path: MosaicPath;
    children: ReactNode;
    createNode?: CreateNode<T>;
    toolbarControls?: ReactNode;
    additionalControls?: ReactNode;
    renderToolbar?: (props: MosaicWindowToolbarProps<T>, defaultToolbar: ReactNode) => ReactNode;
    onDragStart?: () => void;
    onDragEnd?: (type: 'drop' | 'reset') => void;
    onError?: (error: unknown, action: 'split' | 'replace') => void;
    className?: string;
    closable?: boolean;
    hideToolbar?: boolean;
    bodyClassName?: string;
    bodyPadding?: string | number;
    ariaLabel?: string;
    panelId?: T;
}
interface MosaicWindowToolbarProps<T extends MosaicKey> {
    title: string;
    path: MosaicPath;
    createNode?: CreateNode<T>;
    toolbarControls?: ReactNode;
    additionalControls?: ReactNode;
    dragHandle: DragBindings;
    closable?: boolean;
    onError?: (error: unknown, action: 'split' | 'replace') => void;
}
declare const MosaicWindowImpl: <T extends MosaicKey>({ title, path, children, createNode, toolbarControls, additionalControls, renderToolbar, onDragStart, onDragEnd, onError, className, closable, hideToolbar, bodyClassName, bodyPadding, ariaLabel, panelId, }: MosaicWindowProps<T>) => react_jsx_runtime.JSX.Element;
declare const MosaicWindow: typeof MosaicWindowImpl;

interface SplitProps {
    direction: MosaicDirection;
    percentage: number;
    onChange: (percentage: number) => void;
    onRelease?: (percentage: number) => void;
    boundingBox: BoundingBox;
    minimumPaneSizePercentage?: number;
}
declare const Split: ({ direction, percentage, onChange, onRelease, boundingBox, minimumPaneSizePercentage, }: SplitProps) => react_jsx_runtime.JSX.Element;

interface MosaicDropTargetProps {
    position: MosaicDropTargetPosition;
    path: MosaicPath;
    mosaicId: string;
    hitArea?: 'window' | 'viewport-edge';
}
declare const MosaicDropTarget: react__default.MemoExoticComponent<({ position, path, mosaicId, hitArea, }: MosaicDropTargetProps) => react_jsx_runtime.JSX.Element>;

type GetDirectionFn = (nextCount: number) => MosaicDirection;
interface MosaicLayoutProps<TId extends MosaicKey = string> extends Omit<MosaicProps<TId>, 'renderTile' | 'value' | 'onChange' | 'initialValue'> {
    panels: MosaicPanelConfig<TId>[];
    className?: string;
    initialNode?: MosaicNode<TId> | null;
    getDirection?: GetDirectionFn;
    onPanelClose?: (id: TId) => void;
    onNodeChange?: (node: MosaicNode<TId> | null) => void;
}
declare function MosaicLayout<TId extends MosaicKey = string>({ panels, className, initialNode, getDirection, onPanelClose, onNodeChange, ...mosaicProps }: MosaicLayoutProps<TId>): react_jsx_runtime.JSX.Element;

declare function useMosaicPanels<TId extends MosaicKey = string>(): {
    panels: MosaicPanelConfig<TId>[];
    addPanel: (panel: MosaicPanelConfig<TId>) => void;
    removePanel: (id: TId) => void;
    togglePanel: (panelOrId: MosaicPanelConfig<TId> | TId) => void;
    hasPanel: (id: TId) => boolean;
    clearPanels: () => void;
    updatePanel: (id: TId, updates: Partial<MosaicPanelConfig<TId>>) => void;
    getPanelById: (id: TId) => MosaicPanelConfig<TId> | null;
};

interface PersistedPanelEntry<TProps = Record<string, never>> {
    component: ComponentType<TProps>;
    toolbar?: ComponentType;
    wrapper?: ComponentType<{
        children: ReactNode;
    }>;
    closable?: boolean;
    title?: string;
    componentProps?: TProps extends Record<string, never> ? never : TProps;
}
type PersistedLayoutRegistry<TId extends MosaicKey = string> = Record<TId, PersistedPanelEntry<any>>;
type ValidatedRegistry<R> = {
    [K in keyof R]: R[K] extends {
        component: ComponentType<infer P>;
    } ? PersistedPanelEntry<P> : R[K];
};
declare function defineRegistry<const R extends Record<string, PersistedPanelEntry<any>>>(registry: R & ValidatedRegistry<R>): R;
interface UsePersistedLayoutOptions<TId extends MosaicKey = string> {
    storageKey: string;
    registry: PersistedLayoutRegistry<TId>;
    titles?: Partial<Record<TId, string>>;
    defaultPanelIds?: TId[];
    autoSaveDelayMs?: number;
    syncAcrossTabs?: boolean;
    onSave?: (node: MosaicNode<TId> | null) => void;
    onReset?: (node: MosaicNode<TId> | null) => void;
    onPanelOpen?: (id: TId) => void;
    onPanelClose?: (id: TId) => void;
    onNodeChange?: (node: MosaicNode<TId> | null) => void;
}
interface UsePersistedLayoutResult<TId extends MosaicKey = string> {
    panels: MosaicPanelConfig<TId>[];
    initialNode: MosaicNode<TId> | null;
    onNodeChange: (node: MosaicNode<TId> | null) => void;
    saveLayout: () => void;
    addPanel: (id: TId) => void;
    removePanel: (id: TId) => void;
    hasPanel: (id: TId) => boolean;
    activeIds: ReadonlySet<TId>;
    isDirty: boolean;
    clearLayout: () => void;
    resetLayout: () => void;
    PanelStateProvider: ComponentType<{
        children: ReactNode;
    }>;
}
declare function usePersistedLayout<TId extends MosaicKey = string>(options: UsePersistedLayoutOptions<TId>): UsePersistedLayoutResult<TId>;

interface UsePanelStateOptions<T> {
    defaultState: T | (() => T);
    version?: number;
    migrate?: (persisted: unknown, fromVersion: number) => T;
}
declare function usePanelState<T>(options: UsePanelStateOptions<T>): [T, (updater: T | ((prev: T) => T)) => void];

declare const isParent: <T extends MosaicKey>(node: MosaicNode<T> | null) => node is MosaicParent<T>;
declare const getLeaves: <T extends MosaicKey>(node: MosaicNode<T> | null) => T[];
declare const pruneTree: <T extends MosaicKey>(node: MosaicNode<T> | null, validIds: Set<T>) => MosaicNode<T> | null;
declare const getNodeAtPath: <T extends MosaicKey>(node: MosaicNode<T>, path: MosaicPath) => MosaicNode<T> | null;
declare const getAndAssertNodeAtPathExists: <T extends MosaicKey>(node: MosaicNode<T>, path: MosaicPath) => MosaicNode<T>;
declare const createBalancedTreeFromLeaves: <T extends MosaicKey>(leaves: T[], startDirection?: MosaicDirection) => MosaicNode<T> | null;
declare const getPathToCorner: <T extends MosaicKey>(node: MosaicNode<T>, corner: Corner) => MosaicPath;
declare const getOtherDirection: (direction: MosaicDirection) => MosaicDirection;
declare const getOtherBranch: (branch: MosaicBranch) => MosaicBranch;
declare const countNodes: <T extends MosaicKey>(node: MosaicNode<T> | null) => number;
declare const getTreeDepth: <T extends MosaicKey>(node: MosaicNode<T> | null) => number;

declare const updateTree: <T extends MosaicKey>(root: MosaicNode<T> | null, updates: MosaicUpdate<T>[]) => MosaicNode<T> | null;
declare const createRemoveUpdate: <T extends MosaicKey>(root: MosaicNode<T> | null, path: MosaicPath) => MosaicUpdate<T>;
declare const createExpandUpdate: <T extends MosaicKey>(path: MosaicPath, percentage?: number) => MosaicUpdate<T>;
declare const createHideUpdate: <T extends MosaicKey>(path: MosaicPath) => MosaicUpdate<T>;
declare const createDragToUpdates: <T extends MosaicKey>(root: MosaicNode<T>, sourcePath: MosaicPath, destinationPath: MosaicPath, position: MosaicDropTargetPosition) => MosaicUpdate<T>[];
declare const createReplaceUpdate: <T extends MosaicKey>(path: MosaicPath, node: MosaicNode<T>) => MosaicUpdate<T>;
declare const createSplitUpdate: <T extends MosaicKey>(root: MosaicNode<T>, path: MosaicPath, newNode: T, direction?: MosaicDirection) => MosaicUpdate<T>;

declare const MosaicContext: react.Context<MosaicContextValue<any>>;
declare const MosaicWindowContext: react.Context<MosaicWindowContextValue<any>>;
declare function useMosaicContext<T extends MosaicKey = string>(): MosaicContextValue<T>;
declare function useMosaicWindowContext<T extends MosaicKey = string>(): MosaicWindowContextValue<T>;

export { Corner, Mosaic, MosaicContext, MosaicDropTarget, MosaicDropTargetPosition, MosaicLayout, MosaicWindow, MosaicWindowContext, Split, countNodes, createBalancedTreeFromLeaves, createDragToUpdates, createExpandUpdate, createHideUpdate, createRemoveUpdate, createReplaceUpdate, createSplitUpdate, defineRegistry, getAndAssertNodeAtPathExists, getLeaves, getNodeAtPath, getOtherBranch, getOtherDirection, getPathToCorner, getTreeDepth, isParent, pruneTree, updateTree, useMosaicContext, useMosaicPanels, useMosaicWindowContext, usePanelState, usePersistedLayout };
export type { BoundingBox, CreateNode, DragBindings, GetDirectionFn, MosaicBranch, MosaicContextValue, MosaicControlledProps, MosaicDirection, MosaicDragItem, MosaicDropData, MosaicDropTargetProps, MosaicKey, MosaicLayoutProps, MosaicNode, MosaicPanelConfig, MosaicParent, MosaicPath, MosaicProps, MosaicRootActions, MosaicUncontrolledProps, MosaicUpdate, MosaicUpdateSpec, MosaicWindowActions, MosaicWindowContextValue, MosaicWindowProps, MosaicWindowToolbarProps, PersistedLayoutRegistry, PersistedPanelEntry, ResizeOptions, SplitProps, TileRenderer, UsePanelStateOptions, UsePersistedLayoutOptions, UsePersistedLayoutResult };