import { type ViewStyle, type TextStyle } from "react-native";
import { type ColorTokens } from "../../style/index.js";
export type Density = "compact" | "regular" | "comfortable";
/** A sheet look's parts (`reference`, `bare`, `matrix`): each replaces the skin's own part. */
export interface DataTableSheet {
    frame: (t: ColorTokens) => ViewStyle;
    columns: ViewStyle;
    headerRow: (t: ColorTokens) => ViewStyle;
    headerCell: (t: ColorTokens) => TextStyle;
    dataRow: (t: ColorTokens) => ViewStyle;
    cellPad: ViewStyle;
    /** The header cell's inset (none on either side when absent: the columns space it). */
    cellInset?: ViewStyle;
    groupBand: (t: ColorTokens) => ViewStyle;
    footerRule: (t: ColorTokens) => ViewStyle;
}
export interface DataTableSkin {
    /** Web cell editors use clear Liquid Glass without changing field geometry. */
    liquidTextEntry?: boolean;
    /** The outer wrap (clips the rounded corners). */
    wrap: ViewStyle;
    /** The `bordered` rounded outline around the whole table. */
    borderedOutline: (t: ColorTokens) => ViewStyle;
    /**
     * The frame a standalone table draws without `bordered` (its corner, hairline and fill);
     * dropped when `attached` puts the table inside a frame its parent draws. Absent where a
     * standalone table draws no frame (iOS).
     */
    frame?: (t: ColorTokens) => ViewStyle;
    /**
     * Mark the sorted column with an arrow in the accent (the hand-off's sort mark) rather
     * than a muted chevron (SwiftUI Table's).
     */
    sortArrows?: boolean;
    /** The header band (a flex row on the muted surface). */
    headerRow: (t: ColorTokens) => ViewStyle;
    /**
     * Layered over `headerRow` when the table is framed (`attached`, or its own
     * `bordered` outline): the band squares its corners to the frame, whose
     * clipped corners are then the only rounded ones. Null where the band is
     * square already (iOS, Android).
     */
    headerRowAttached: ViewStyle | null;
    /** Header vertical padding per density (horizontal padding lives on the cell). */
    headerPad: Record<Density, ViewStyle>;
    /**
     * A header column label — TYPE ONLY (size/weight/case/tracking/color). The
     * shell owns the header cell BOX (the equal-width flex share, the horizontal
     * padding, the label+sort-icon row), so the label can sit beside a sort
     * indicator without each skin re-declaring the layout.
     */
    headerCell: (t: ColorTokens) => TextStyle;
    /**
     * The `reference` look: the v4 hand-off's reference sheet (its props table,
     * Component.dc.html lines 233 to 241). Each part replaces the skin's own: `frame` the
     * standalone frame and the `bordered` outline, `headerRow` the header band and the
     * density's `headerPad`, `headerCell` the heading type, `dataRow` the row, `cellPad`
     * the density's cell padding, `groupBand` the band, and `footerRule` is drawn under
     * every footer. The sheet spaces its columns with the row's own gap and side inset
     * (`columns` on the header row, every row and a `stacks` table's cell group), so no
     * cell carries horizontal padding of its own, and each rule sits above what draws it.
     * Absent on a platform whose own table control draws the table (iOS), where the
     * boolean changes nothing.
     */
    reference?: DataTableSheet;
    /**
     * The `bare` look: the v4 Layout page's sizing table (Layout.dc.html, `c-sizing`), a
     * hairline table with no frame and no fill. The same parts as `reference`, each replacing
     * the skin's own; absent where the platform's own table control draws the table (iOS).
     */
    bare?: DataTableSheet;
    /**
     * The `matrix` look: a section page's specimen grid (Controls.dc.html, `c-button`), no
     * frame, fill or rules, unpadded cells 12 apart in rows and 20 apart in columns. Absent
     * where the platform's own table control draws the table (iOS).
     */
    matrix?: DataTableSheet;
    /** Size (px) of the sort-direction indicator icon beside a sortable header label. */
    sortIconSize: number;
    /**
     * Muted caption type: the footer's "N selected" count and the built-in
     * `emptyMessage` text.
     */
    captionText: (t: ColorTokens) => TextStyle;
    /** The leading checkbox column (narrow, fixed width). */
    selectCol: ViewStyle;
    /** The selection cell in a data row (the narrow column plus row padding). */
    selectCell: ViewStyle;
    /** A data row (flex row, vertically centered, with a hairline beneath it). */
    dataRow: (t: ColorTokens) => ViewStyle;
    /**
     * The hairline the `footer` row draws above itself when nothing above it draws one
     * (the pagination bar, the empty message, a header with no rule): the platform's row
     * rule.
     */
    footerRule: (t: ColorTokens) => ViewStyle;
    /**
     * A group band (`groups`): the row spanning every column above a group's rows, on
     * the sunken fill, with its padding and the row layout. The shell turns the fill into
     * an ink tint under glass.
     */
    groupBand: (t: ColorTokens) => ViewStyle;
    /** A group band's label type. */
    groupLabel: (t: ColorTokens) => TextStyle;
    /** A group band's count type: the muted monospace meta line. */
    groupCount: (t: ColorTokens) => TextStyle;
    /** The striped tint on alternating (odd-index) rows. */
    stripeTint: (t: ColorTokens) => ViewStyle;
    /** The pressed tint for a pressable row (iOS/web tint via this; Android ripples). */
    pressTint: (t: ColorTokens) => ViewStyle;
    /** Cell vertical/horizontal padding per density. */
    cellPad: Record<Density, ViewStyle>;
    /** A content cell (equal-width column box; padding added per density). */
    dataCell: ViewStyle;
    /** A data cell's text (the platform's body type on the foreground color). */
    cellText: (t: ColorTokens) => TextStyle;
    /**
     * A `stacks` table's column label above a stacked cell's value: the platform's
     * smallest label role in the muted color, so it stays below any cell text,
     * the kit's small Typography included (the docs' prop descriptions).
     */
    stackedLabel: (t: ColorTokens) => TextStyle;
    /**
     * An inset row separator hairline (iOS lists inset the separator to the content
     * leading edge). When set, the shell renders it as an absolutely-positioned
     * bottom hairline inside each row and the `dataRow` carries no borderBottom;
     * null keeps the full-bleed borderBottom on `dataRow` (web/Android).
     */
    separator: ((t: ColorTokens) => ViewStyle) | null;
    /**
     * Fixed width of the trailing row-actions column (`onRowEdit`/`onRowDelete`):
     * two icon buttons at the platform touch-target size, plus the cell padding.
     */
    actionsColWidth: number;
    /**
     * One icon action button (pencil / bin / save / cancel): a square box at the
     * platform touch-target size (web 28, iOS 44pt, Android 48dp), centered.
     */
    actionButton: ViewStyle;
    /** Size (px) of the glyphs inside the trailing action buttons. */
    actionIconSize: number;
    /**
     * The inline cell editor (`inlineEdit` / pencil-opened row editing): the
     * platform's cell type inside a primary-ringed field on the background fill.
     */
    editInput: (t: ColorTokens) => TextStyle;
    /** The wash over a row while it is in pencil-opened edit mode. */
    editTint: (t: ColorTokens) => ViewStyle;
    /**
     * Collapse a multicolumn table to its PRIMARY (first) column below the compact
     * (`sm`) width, matching SwiftUI Table's compact-width behavior on iPhone. iOS
     * only; web/Android render every column at every width.
     */
    collapsesToPrimaryColumn?: boolean;
    /**
     * Minimum height for a pressable row so the tap target clears the platform
     * minimum (iOS 44pt / M3 48dp), applied only when `onRowPress` is set. Web omits
     * it (no touch-target requirement on the pointer web).
     */
    pressableMinHeight?: number;
    /** Android ripple over a pressable row; null on iOS/web. */
    ripple: ((t: ColorTokens) => {
        color: string;
        borderless: boolean;
    }) | null;
}
export declare const webSkin: DataTableSkin;
export declare const iosSkin: DataTableSkin;
export declare const androidSkin: DataTableSkin;
//# sourceMappingURL=data-table.styles.d.ts.map