import { type ReactNode } from "react";
import { type LayoutChangeEvent, type StyleProp, type ViewStyle } from "react-native";
/**
 * The wrapper's clip style: the rounded `shape` plus `overflow:"hidden"` on Android, and
 * nothing anywhere else. Pure and platform-parameterized so it is unit-testable without a
 * device (the render harness always reports `web`). `RippleClip` calls it with
 * `Platform.OS === "android"`.
 */
export declare function rippleClipWrapperStyle(shape: StyleProp<ViewStyle> | undefined, isAndroid: boolean): StyleProp<ViewStyle>;
export interface RippleClipProps {
    /**
     * The rounded corners to clip the child's bounded ripple to, matching the child node's
     * own radii (e.g. `{ borderRadius: 9999 }`, or per-corner radii for a segment). Applied
     * only on Android; omit it (or pass undefined) where the child has no bounded ripple.
     */
    shape?: StyleProp<ViewStyle>;
    /**
     * Outer layout composition carried on the wrapper so it stays the outermost node on every
     * platform: block/full width, flex, `alignSelf`, and the consumer's own `style`. Positioning
     * lives here, not on the wrapped pressable, so layout is identical with or without the clip.
     */
    style?: StyleProp<ViewStyle>;
    /**
     * Layout observation on the wrapper (the control's outermost node), so a parent that
     * positions its children — a tab row scrolling the active trigger into view — measures
     * the same frame on every platform, clip or no clip.
     */
    onLayout?: (event: LayoutChangeEvent) => void;
    children: ReactNode;
}
/** Rounded clip parent for a bounded-ripple pressable. See the file header for the why. */
export declare function RippleClip({ shape, style, onLayout, children }: RippleClipProps): ReactNode;
/**
 * Extract only the corner-radius keys from a resolved style, so a `<RippleClip>` parent can
 * clip to the SAME corners its child draws with no hard-coded, drift-prone radius. Pass the
 * child's own (static) shape style: `<RippleClip shape={cornerRadii(skin.trigger(tokens))}>`.
 */
export declare function cornerRadii(style: StyleProp<ViewStyle>): ViewStyle;
/**
 * Split an elevation/shadow style for an ELEVATED node whose ripple is being clipped by a
 * `<RippleClip>` parent. On Android the parent's child-clip would cut the child's own elevation
 * shadow, so the Android `elevation` must move to the PARENT (whose own elevation shadow, drawn
 * around its outline, is not clipped by its child-overflow). The iOS `shadow*` props must stay on
 * the child, exactly where they are today, so iOS is byte-identical.
 *
 * Returns `{ parent, child }`:
 *  - `parent`: the Android `elevation` to spread on the RippleClip (null off Android).
 *  - `child`: the original shadow with `elevation` zeroed on Android (so it is not drawn twice),
 *    and returned UNCHANGED off Android (iOS keeps its shadow* verbatim).
 *
 * Usage: `const { parent, child } = splitElevation(skin.elevation(e));`
 * then `<RippleClip shape={...} style={parent}><Pressable style={[base, child, ...]} .../>`.
 */
export declare function splitElevation(shadowStyle: StyleProp<ViewStyle>): {
    parent: ViewStyle | null;
    child: ViewStyle;
};
//# sourceMappingURL=ripple-clip.d.ts.map