import * as react_jsx_runtime from 'react/jsx-runtime';
import * as React from 'react';
import { FloatingSheetSide, FloatingSheetSize } from '../../lib/floating-sheet-panel.js';
export { FLOATING_SHEET_CHROME_CLASS, FLOATING_SHEET_COMPACT_WIDTH, FLOATING_SHEET_DESKTOP_WIDTH, FLOATING_SHEET_SIZES, FLOATING_SHEET_SIZE_LABEL, FLOATING_SHEET_SIZE_WIDTH, floatingSheetSizeStorageKey, floatingSheetWidthClass, getFloatingSheetInsetProps, useCompactFloatingSheet } from '../../lib/floating-sheet-panel.js';
import { Sheet, SheetContent } from './sheet.js';
import 'radix-ui';

/**
 * Controlled floating sheet root — alias of `Sheet` with the rail behaviour:
 *
 * - **Non-modal.** No focus trap, no scroll lock, no `pointer-events: none` on
 *   the body, so the hub behind stays clickable while the rail is open. This is
 *   an inspector beside the work, not a door in front of it.
 * - **Single rail.** Opening this panel closes whichever rail was already open.
 * - **Sticky.** Clicking the hub does not dismiss it (`SheetContent` blocks
 *   outside dismissal); Escape and the close button do.
 */
declare function FloatingSheetPanel({ exclusive, modal, ...props }: React.ComponentProps<typeof Sheet> & {
    /**
     * Set `false` to let this panel coexist with another open rail. Only correct
     * when the two are pinned to opposite edges and genuinely belong on screen
     * together.
     */
    exclusive?: boolean;
}): react_jsx_runtime.JSX.Element;
interface FloatingSheetPanelContentProps extends Omit<React.ComponentProps<typeof SheetContent>, "side" | "showCloseButton" | "showOverlay" | "size"> {
    /** Rail edge. Default `right`. */
    side?: FloatingSheetSide;
    /**
     * Width the rail opens at: `sm` 24rem (default), `md` 32rem, `lg` 40rem.
     * The user can change this from the toolbar's size menu or by dragging, and
     * both choices are remembered per `contentSlot`.
     */
    size?: FloatingSheetSize;
    /**
     * Applied to `SheetContent` as `data-slot` (e.g. `export-drawer`). Also keys
     * the remembered size and drag width, so each drawer keeps its own.
     */
    contentSlot?: string;
}
declare function FloatingSheetPanelContent({ side, size, className, style, contentSlot, children, resizable, resizeStorageKey, onOpenAutoFocus, ...props }: FloatingSheetPanelContentProps): react_jsx_runtime.JSX.Element;
interface FloatingSheetPanelToolbarProps {
    /**
     * Return to the rail's root panel. Set this while a sub-panel is showing:
     * back takes the leading slot on the left. Close stays on the right either
     * way, so a user two levels into Properties can still leave in one action
     * instead of backing out step by step (Escape is the only other full exit,
     * and it is not discoverable the way a visible control is).
     */
    onBack?: () => void;
    backLabel?: string;
    /**
     * Step to the previous and next record. Wire these only when the rail is
     * showing one of an ordered set (a table row detail); omit for rails that
     * are not about a record, such as Export.
     */
    onPrevious?: () => void;
    onNext?: () => void;
    previousLabel?: string;
    nextLabel?: string;
    /** Label read out for the size menu. */
    sizeLabel?: string;
    /** Hide the size menu on rails whose width is fixed by their content. */
    showSize?: boolean;
    closeLabel?: string;
    /**
     * Extra controls in the right-hand cluster: share, favourite, overflow.
     * Icon-only buttons in `Tip`. Rendered after size/stepping but before
     * Close, which always stays last, at the panel's outer edge.
     */
    actions?: React.ReactNode;
    className?: string;
    /** Extra classes on each `Tip`, for rails that need a higher tooltip z-index. */
    tipClassName?: string;
    tipZIndex?: number;
}
/**
 * Top row of a rail: Back on the left when there is somewhere to go back to,
 * everything else — size, record stepping, consumer `actions`, Close — in one
 * right-aligned cluster, in that fixed order.
 *
 * Close trails the cluster, at the panel's outer corner, and renders whether
 * or not `onBack` or `actions` are set, on purpose: it is the one control
 * every rail carries ("leave the rail" is never optional the way stepping or
 * a size menu are), so it gets the one position that is always the same
 * corner regardless of how many other controls a given panel happens to add.
 * A user who drilled into Filter or Sort still needs a one-click way out, not
 * N presses of Back or a keyboard-only Escape they may not know about —
 * mirroring the common back-top-left / close-top-right convention.
 */
declare function FloatingSheetPanelToolbar({ onBack, backLabel, onPrevious, onNext, previousLabel, nextLabel, sizeLabel, showSize, closeLabel, actions, className, tipClassName, tipZIndex, }: FloatingSheetPanelToolbarProps): react_jsx_runtime.JSX.Element;
interface FloatingSheetPanelHeaderProps {
    /** Required accessible title — renders as `SheetTitle`. */
    title: React.ReactNode;
    /** Muted line under the title (Properties lifecycle label). */
    subtitle?: React.ReactNode;
    /** Helper copy below the header row (`SheetDescription`). */
    description?: React.ReactNode;
    /**
     * Only for rails with no toolbar. When a toolbar is present it owns close, so
     * that there is one way out rather than two.
     */
    onClose?: () => void;
    closeLabel?: string;
    className?: string;
    titleClassName?: string;
    /** Extra classes on the close-button `Tip` (e.g. Properties sheet z-index). */
    closeTipClassName?: string;
    closeTipZIndex?: number;
}
declare function FloatingSheetPanelHeader({ title, subtitle, description, onClose, closeLabel, className, titleClassName, closeTipClassName, closeTipZIndex, }: FloatingSheetPanelHeaderProps): react_jsx_runtime.JSX.Element;
type FloatingSheetPanelBodyProps = React.ComponentProps<"div">;
declare function FloatingSheetPanelBody({ className, children, onScroll, tabIndex, ref, ...props }: FloatingSheetPanelBodyProps): react_jsx_runtime.JSX.Element;
type FloatingSheetPanelFooterProps = React.ComponentProps<"div">;
declare function FloatingSheetPanelFooter({ className, children, ...props }: FloatingSheetPanelFooterProps): react_jsx_runtime.JSX.Element;
interface FloatingSheetPanelWorkflowFooterProps {
    cancelLabel?: string;
    onCancel: () => void;
    primaryLabel: React.ReactNode;
    /** When set, primary button uses `type="submit"` + `form={primaryForm}`. */
    primaryForm?: string;
    /** Invoked by ⌘/plain Enter shortcut while the sheet is open. */
    onPrimary?: () => void;
    primaryDisabled?: boolean;
    primaryLoading?: boolean;
    primaryLoadingLabel?: React.ReactNode;
    primaryIconClassName?: string;
    className?: string;
}
declare function FloatingSheetPanelWorkflowFooter({ cancelLabel, onCancel, primaryLabel, primaryForm, onPrimary, primaryDisabled, primaryLoading, primaryLoadingLabel, primaryIconClassName, className, }: FloatingSheetPanelWorkflowFooterProps): react_jsx_runtime.JSX.Element;

export { FloatingSheetPanel, FloatingSheetPanelBody, type FloatingSheetPanelBodyProps, FloatingSheetPanelContent, type FloatingSheetPanelContentProps, FloatingSheetPanelFooter, type FloatingSheetPanelFooterProps, FloatingSheetPanelHeader, type FloatingSheetPanelHeaderProps, FloatingSheetPanelToolbar, type FloatingSheetPanelToolbarProps, FloatingSheetPanelWorkflowFooter, type FloatingSheetPanelWorkflowFooterProps, FloatingSheetSide, FloatingSheetSize };