/* @silk-hq/components | (c) 2025 Bruno Stasse | SEE LICENSE FILE */

import React from "react";
export declare namespace mapping {
    namespace Sheet {
        const componentName: string;
        namespace elementNames {
            const root: number;
            const view: number;
            const backdrop: number;
            const backdropTrap: number;
            const primaryScrollTrapRoot: number;
            const secondaryScrollTrapRoot: number;
            const scrollContainer: number;
            const frontSpacer: number;
            const backSpacer: number;
            const detentMarker: number;
            const contentWrapper: number;
            const content: number;
            const bleedingBackground: number;
            const stickyContainer: number;
            const sticky: number;
            const leftEdge: number;
            const trigger: number;
            const handle: number;
            const outlet: number;
        }
        namespace variationSetsNames {
            const openness: string;
            const staging: string;
            const opennessClosedStatus: string;
            const position: string;
            const positionCoveredStatus: string;
            const placement: string;
            const track: string;
            const swipeDisabled: string;
            const swipeOutDisabledWithDetent: string;
            const swipeOvershootDisabled: string;
            const bleedDisabled: string;
            const inertOutside: string;
            const backdropSwipeable: string;
            const scrollContainerShouldBePassThrough: string;
            const swipeTrap: string;
        }
        const variationValuesNames: {
            open: string;
            opening: string;
            closed: string;
            closing: string;
            none: string;
            top: string;
            bottom: string;
            left: string;
            right: string;
            horizontal: string;
            vertical: string;
            front: string;
            covered: string;
            true: string;
            false: string;
            auto: string;
            center: string;
            pending: string;
            "flushing-to-preparing-open": string;
            "flushing-to-preparing-opening": string;
            "preparing-open": string;
            "preparing-opening": string;
            "safe-to-unmount": string;
            content: string;
            root: string;
            "going-down": string;
            "going-up": string;
            indeterminate: string;
            idle: string;
            "come-back": string;
            out: string;
            stepping: string;
            both: string;
        };
    }
    namespace ScrollTrap {
        const componentName_1: string;
        export { componentName_1 as componentName };
        export namespace elementNames_1 {
            const root_1: number;
            export { root_1 as root };
            export const stabiliser: number;
        }
        export { elementNames_1 as elementNames };
        export namespace variationSetsNames_1 {
            const active: string;
            const axis: string;
            const automaticallyDisabledForOptimisation: string;
        }
        export { variationSetsNames_1 as variationSetsNames };
        export namespace variationValuesNames_1 {
            const _true: string;
            export { _true as true };
            const _false: string;
            export { _false as false };
            export const horizontal: string;
            export const vertical: string;
            export const both: string;
            export const none: string;
        }
        export { variationValuesNames_1 as variationValuesNames };
    }
    namespace Scroll {
        const componentName_2: string;
        export { componentName_2 as componentName };
        export namespace elementNames_2 {
            const root_2: number;
            export { root_2 as root };
            const view_1: number;
            export { view_1 as view };
            const scrollContainer_1: number;
            export { scrollContainer_1 as scrollContainer };
            const content_1: number;
            export { content_1 as content };
            export const UAScrollbarMeasurer: number;
            export const spy: number;
            export const startSpacer: number;
            export const endSpacer: number;
        }
        export { elementNames_2 as elementNames };
        export namespace variationSetsNames_2 {
            const axis_1: string;
            export { axis_1 as axis };
            export const contentPlacement: string;
            export const scrollTrapX: string;
            export const scrollTrapY: string;
            export const scrollGestureOvershoot: string;
            export const scrollDisabled: string;
            export const side: string;
            export const pageScroll: string;
            export const overflowX: string;
            export const overflowY: string;
            export const skipScrollAnimation: string;
            export const scrollAnchoring: string;
            export const scrollSnapType: string;
            export const scrollPadding: string;
            export const scrollTimelineName: string;
            export const nativeScrollbar: string;
            export const scrollOngoing: string;
        }
        export { variationSetsNames_2 as variationSetsNames };
        export namespace variationValuesNames_2 {
            const _true_1: string;
            export { _true_1 as true };
            const _false_1: string;
            export { _false_1 as false };
            export const x: string;
            export const y: string;
            const both_1: string;
            export { both_1 as both };
            export const unset: string;
            export const contain: string;
            export const start: string;
            export const end: string;
            export const center: string;
            export const auto: string;
            const _default: string;
            export { _default as default };
            const none_1: string;
            export { none_1 as none };
            export const mandatoryX: string;
            export const mandatoryY: string;
            export const proximityX: string;
            export const proximityY: string;
        }
        export { variationValuesNames_2 as variationValuesNames };
    }
    namespace SlideShow {
        const componentName_3: string;
        export { componentName_3 as componentName };
        const elementNames_3: {};
        export { elementNames_3 as elementNames };
        const variationSetsNames_3: {};
        export { variationSetsNames_3 as variationSetsNames };
        const variationValuesNames_3: {};
        export { variationValuesNames_3 as variationValuesNames };
    }
    namespace VisuallyHidden {
        const componentName_4: string;
        export { componentName_4 as componentName };
        export namespace elementNames_4 {
            const root_3: number;
            export { root_3 as root };
        }
        export { elementNames_4 as elementNames };
        const variationSetsNames_4: {};
        export { variationSetsNames_4 as variationSetsNames };
        const variationValuesNames_4: {};
        export { variationValuesNames_4 as variationValuesNames };
    }
    namespace SpecialWrapper {
        const componentName_5: string;
        export { componentName_5 as componentName };
        export namespace elementNames_5 {
            const root_4: number;
            export { root_4 as root };
            const content_2: number;
            export { content_2 as content };
        }
        export { elementNames_5 as elementNames };
        const variationSetsNames_5: {};
        export { variationSetsNames_5 as variationSetsNames };
        const variationValuesNames_5: {};
        export { variationValuesNames_5 as variationValuesNames };
    }
    namespace Fixed {
        const componentName_6: string;
        export { componentName_6 as componentName };
        export namespace elementNames_6 {
            const root_5: number;
            export { root_5 as root };
        }
        export { elementNames_6 as elementNames };
        const variationSetsNames_6: {};
        export { variationSetsNames_6 as variationSetsNames };
        const variationValuesNames_6: {};
        export { variationValuesNames_6 as variationValuesNames };
    }
    namespace SheetStack {
        const componentName_7: string;
        export { componentName_7 as componentName };
        export namespace elementNames_7 {
            const root_6: number;
            export { root_6 as root };
            const outlet_1: number;
            export { outlet_1 as outlet };
        }
        export { elementNames_7 as elementNames };
        const variationSetsNames_7: {};
        export { variationSetsNames_7 as variationSetsNames };
        const variationValuesNames_7: {};
        export { variationValuesNames_7 as variationValuesNames };
    }
    namespace AutoFocusTarget {
        const componentName_8: string;
        export { componentName_8 as componentName };
        export namespace elementNames_8 {
            const root_7: number;
            export { root_7 as root };
        }
        export { elementNames_8 as elementNames };
        const variationSetsNames_8: {};
        export { variationSetsNames_8 as variationSetsNames };
        const variationValuesNames_8: {};
        export { variationValuesNames_8 as variationValuesNames };
    }
}
type Track = "top" | "bottom" | "left" | "right";
type TrackProp = Track | ["top", "bottom"] | ["bottom", "top"] | ["right", "left"] | ["left", "right"];
type SheetId = React.Context<any>;
type SheetStackId = React.Context<any>;
type ScrollId = React.Context<any>;
type ComponentId = React.Context<any>;
type TravelStatus = "entering" | "idleInside" | "stepping" | "exiting" | "idleOutside";
type DetentIndex = number;
type TravelRange = {
    start: DetentIndex;
    end: DetentIndex;
};
type TravelProgress = number;
type TravelProgressAtDetents = Array<TravelProgress>;
type ValidCSSValue = string | number;
type ValidNumericalCSSValue = string | number;
type TweenFunction = (start: ValidNumericalCSSValue, end: ValidNumericalCSSValue) => string;
interface CssValueTemplateParams {
    progress: TravelProgress;
    tween: TweenFunction;
}
type CssValueTemplate = (param: CssValueTemplateParams) => ValidCSSValue;
type CSSPropertySupportedInValueKeyframes = "opacity" | "translate" | "translateX" | "translateY" | "translateZ" | "scale" | "scaleX" | "scaleY" | "scaleZ" | "rotate" | "rotateX" | "rotateY" | "rotateZ" | "skew" | "skewX" | "skewY";
type CSSPropertiesSupportedInValueKeyframesAnimationDeclarations = {
    [properties in CSSPropertySupportedInValueKeyframes]?: [ValidCSSValue, ValidCSSValue] | CssValueTemplate | string | null | undefined;
};
type AllPropertiesAnimationDeclarations = {
    [property: string]: CssValueTemplate | string | null | undefined;
};
type AnimationDeclarations = CSSPropertiesSupportedInValueKeyframesAnimationDeclarations | AllPropertiesAnimationDeclarations;
type TravelAnimationPropValue = AnimationDeclarations;
type StackingAnimationPropValue = AnimationDeclarations;
type SpringPreset = "gentle" | "smooth" | "snappy" | "brisk" | "bouncy" | "elastic";
type StaticAnimationOptions = {
    preset?: SpringPreset;
    skip?: boolean;
    contentMove?: boolean;
};
type SpringConfig = {
    easing: "spring";
    stiffness: number;
    damping: number;
    mass: number;
    initialVelocity?: number;
    precision?: number;
    delay?: number;
};
type CSSEasingConfig = {
    easing: "ease" | "ease-in" | "ease-out" | "ease-in-out" | "linear" | `cubic-bezier(${string})`;
    duration: number;
    delay?: number;
};
type EnteringAnimationSettings = SpringPreset | ((SpringConfig & StaticAnimationOptions & {
    track?: Track;
}) | (CSSEasingConfig & StaticAnimationOptions & {
    track?: Track;
}) | (StaticAnimationOptions & {
    track?: Track;
}));
type ExitingAnimationSettings = SpringPreset | ((SpringConfig & StaticAnimationOptions & {
    track?: Track;
}) | (CSSEasingConfig & StaticAnimationOptions & {
    track?: Track;
}) | (StaticAnimationOptions & {
    track?: Track;
}));
type SteppingAnimationSettings = SpringPreset | ((SpringConfig & StaticAnimationOptions) | (CSSEasingConfig & StaticAnimationOptions) | StaticAnimationOptions);
type PresentedState = boolean;
type Detent = number;
interface ClickOutsideHandlerOptions {
    dismiss?: boolean;
    stopOverlayPropagation?: boolean;
}
interface ClickOutsideCustomEvent extends ClickOutsideHandlerOptions {
    nativeEvent?: Event | React.SyntheticEvent;
    changeDefault: (changedBehavior: ClickOutsideHandlerOptions) => void;
}
type ClickOutsideHandlerValue = ((customEvent: ClickOutsideCustomEvent) => void) | ClickOutsideHandlerOptions;
interface EscapeKeyDownHandlerOptions {
    nativePreventDefault?: boolean;
    dismiss?: boolean;
    stopOverlayPropagation?: boolean;
}
interface EscapeKeyDownCustomEvent extends EscapeKeyDownHandlerOptions {
    nativeEvent?: Event | React.SyntheticEvent;
    changeDefault: (changedBehavior: EscapeKeyDownHandlerOptions) => void;
}
type EscapeKeyDownHandlerValue = ((customEvent: EscapeKeyDownCustomEvent) => void) | EscapeKeyDownHandlerOptions;
type SafeArea = "none" | "layout-viewport" | "visual-viewport";
interface OutletExclusiveProps {
    /**
     * ! Limitation: If travelAnimation is updated, the component
     * won't be updated visually right away, it will take the new
     * configuration into account only during the next travel. We
     * may change that behavior in the future so it updates right
     * away.
     */
    travelAnimation?: TravelAnimationPropValue;
    stackingAnimation?: StackingAnimationPropValue;
}
export interface FixedRootProps extends React.HTMLAttributes<HTMLDivElement> {
    asChild?: boolean;
    "data-silk"?: string;
}
export interface FixedContentProps extends React.HTMLAttributes<HTMLDivElement> {
    asChild?: boolean;
    "data-silk"?: string;
}
export const Fixed: {
    Root: React.ForwardRefExoticComponent<FixedRootProps & React.RefAttributes<any>>;
    Content: React.ForwardRefExoticComponent<FixedContentProps & React.RefAttributes<any>>;
};
export interface VisuallyHiddenRootProps extends React.HTMLAttributes<HTMLSpanElement> {
    asChild?: boolean;
    "data-silk"?: string;
}
export const VisuallyHidden: {
    Root: React.ForwardRefExoticComponent<VisuallyHiddenRootProps & React.RefAttributes<any>>;
};
export interface SheetOutletProps extends OutletExclusiveProps, React.HTMLAttributes<HTMLDivElement> {
    forComponent?: SheetId;
    asChild?: boolean;
}
interface TriggerPressHandlerOptions {
    forceFocus?: boolean;
    runAction?: boolean;
}
interface TriggerPressCustomEvent extends TriggerPressHandlerOptions {
    changeDefault: (changedBehavior: TriggerPressHandlerOptions) => void;
    nativeEvent: React.MouseEvent<HTMLElement, MouseEvent>;
}
type TriggerPressHandlerValue = TriggerPressHandlerOptions | ((customEvent: TriggerPressCustomEvent) => void);
interface StepActionWithOptions {
    type: "step";
    direction?: "up" | "down";
    detent?: number;
}
export interface SheetTriggerProps extends OutletExclusiveProps, React.ButtonHTMLAttributes<HTMLButtonElement> {
    asChild?: boolean;
    "data-silk"?: string;
    forComponent?: SheetId;
    action?: "present" | "dismiss" | "step" | StepActionWithOptions;
    onPress?: TriggerPressHandlerValue;
    onClick?: (e: React.MouseEvent<HTMLElement>) => void;
}
interface HandleStepActionWithOptions {
    type: "step";
    direction?: "up" | "down";
}
interface HandleProps extends Omit<SheetTriggerProps, "action"> {
    action?: "step" | HandleStepActionWithOptions | "dismiss";
}
export interface SheetPortalProps {
    container?: HTMLElement | null;
    children: React.ReactNode;
}
export interface SheetRootProps extends React.HTMLAttributes<HTMLDivElement> {
    license: "commercial" | "non-commercial";
    "data-silk"?: string;
    componentId?: SheetId;
    forComponent?: SheetStackId | "closest";
    asChild?: boolean;
    sheetRole?: React.AriaRole;
    defaultPresented?: boolean;
    presented?: PresentedState;
    onPresentedChange?: (presented: PresentedState) => void;
    defaultActiveDetent?: Detent;
    activeDetent?: Detent;
    onActiveDetentChange?: (detent: Detent) => void;
    onSafeToUnmountChange?: (safeToUnmount: boolean) => void;
    children: React.ReactNode;
}
type Travelhandler = ({ progress, range, progressAtDetents, }: {
    progress: TravelProgress;
    range: TravelRange;
    progressAtDetents: TravelProgressAtDetents;
}) => void | (() => void);
type SheetViewFocusInsideCustomEvent = {
    nativeEvent: Event;
};
interface ViewAutoFocusHandlerOptions {
    focus?: boolean;
}
interface ViewAutoFocusCustomEvent extends ViewAutoFocusHandlerOptions {
    nativeEvent: null;
    changeDefault: (changedBehavior: ViewAutoFocusHandlerOptions) => void;
}
type ViewAutoFocusHandlerValue = ViewAutoFocusHandlerOptions | ((customEvent: ViewAutoFocusCustomEvent) => void);
export interface SheetViewProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "role"> {
    forComponent?: SheetId;
    children: React.ReactNode;
    /**
     * Defines the placement of `<Content />` inside of `<View
     * />`. If the value is `top`, `bottom`, `left` or `right`,
     * it will be aligned on the center on the other axis.
     */
    contentPlacement?: "top" | "bottom" | "left" | "right" | "center";
    detents?: string | Array<string>;
    /**
     * Defines the direction the user would have to swipe to move
     * the `<Content />` out of the `<View />`.
     *
     * The `tracks` value must match the `contentPlacement`
     * value (i.e. if `contentPlacement="top"`, than you must have
     * `tracks="top"`), except for
     * `contentPlacement="center"` which can be used with any
     * `tracks` value.
     */
    tracks?: TrackProp;
    swipeOvershoot?: boolean;
    swipeDismissal?: boolean;
    swipe?: boolean;
    swipeTrap?: boolean | {
        x?: boolean;
        y?: boolean;
    };
    nativeEdgeSwipePrevention?: boolean;
    enteringAnimationSettings?: EnteringAnimationSettings;
    exitingAnimationSettings?: ExitingAnimationSettings;
    steppingAnimationSettings?: SteppingAnimationSettings;
    onTravelStatusChange?: (travelStatus: TravelStatus) => void;
    onTravelRangeChange?: (range: TravelRange) => void;
    /**
     * Handlers which gets called on every frame when travel
     * is occurring.
     */
    onTravel?: Travelhandler;
    onTravelStart?: () => void;
    onTravelEnd?: () => void;
    /**
     * When true prevents:
     * - scroll chaining and body scroll;
     * - pointer events for elements outside the View and Islands;
     * - focus on element outside the View and Islands.
     */
    inertOutside?: boolean;
    onPresentAutoFocus?: ViewAutoFocusHandlerValue;
    onDismissAutoFocus?: ViewAutoFocusHandlerValue;
    /**
     * Runs the callback when the user clicks outside of
     * `<Content />`, `<Island />` and any element contained
     * in `<View />`.
     *
     * The default behavior is to close the Sheet if it is
     * the frontmost Sheet. It can be prevented by calling
     * e.preventDefault.
     */
    onClickOutside?: ClickOutsideHandlerValue;
    onEscapeKeyDown?: EscapeKeyDownHandlerValue;
    onFocusInside?: (customEvent: SheetViewFocusInsideCustomEvent) => void;
    nativeFocusScrollPrevention?: boolean;
}
export interface SheetBackdropProps extends OutletExclusiveProps, React.HTMLAttributes<HTMLDivElement> {
    asChild?: boolean;
    "data-silk"?: string;
    swipeable?: boolean;
    themeColorDimming?: false | "auto";
}
export interface SheetContentProps extends React.HTMLAttributes<HTMLDivElement>, OutletExclusiveProps {
    asChild?: boolean;
    "data-silk"?: string;
}
/**
 *  Renders an element in Content that is sized appropriately so
    it can be styled to represent the background of the content
    and bleed in the swipeOut direction, making it visible during
    overshooting.
 */
export interface SheetBleedingBackgroundProps extends React.HTMLAttributes<HTMLDivElement> {
    asChild?: boolean;
    "data-silk"?: string;
}
export interface SheetSpecialWrapperRootProps extends React.HTMLAttributes<HTMLDivElement> {
    asChild?: boolean;
    "data-silk"?: string;
}
export interface SheetSpecialWrapperContentProps extends React.HTMLAttributes<HTMLDivElement> {
    asChild?: boolean;
}
export interface SheetTitleProps extends React.HTMLAttributes<HTMLHeadingElement>, OutletExclusiveProps {
    asChild?: boolean;
    children: React.ReactNode;
}
export interface SheetDescriptionProps extends React.HTMLAttributes<HTMLParagraphElement>, OutletExclusiveProps {
    asChild?: boolean;
    children: React.ReactNode;
}
export const Sheet: {
    Root: React.ForwardRefExoticComponent<SheetRootProps & React.RefAttributes<any>>;
    Trigger: React.ForwardRefExoticComponent<SheetTriggerProps & React.RefAttributes<unknown>>;
    View: React.ForwardRefExoticComponent<SheetViewProps & React.RefAttributes<unknown>>;
    Backdrop: React.ForwardRefExoticComponent<SheetBackdropProps & React.RefAttributes<unknown>>;
    Content: React.ForwardRefExoticComponent<SheetContentProps & React.RefAttributes<unknown>>;
    BleedingBackground: React.ForwardRefExoticComponent<SheetBleedingBackgroundProps & React.RefAttributes<unknown>>;
    Handle: React.ForwardRefExoticComponent<HandleProps & React.RefAttributes<unknown>>;
    SpecialWrapper: {
        Root: React.ForwardRefExoticComponent<SheetSpecialWrapperRootProps & React.RefAttributes<any>>;
        Content: React.ForwardRefExoticComponent<SheetSpecialWrapperContentProps & React.RefAttributes<any>>;
    };
    Outlet: React.ForwardRefExoticComponent<SheetOutletProps & React.RefAttributes<unknown>>;
    Portal: {
        (props: SheetPortalProps): React.ReactPortal | null;
        displayName: string;
    };
    Title: React.ForwardRefExoticComponent<SheetTitleProps & React.RefAttributes<any>>;
    Description: React.ForwardRefExoticComponent<SheetDescriptionProps & React.RefAttributes<any>>;
};
export interface SheetStackRootProps extends React.HTMLAttributes<HTMLDivElement> {
    componentId?: SheetStackId;
    "data-silk"?: string;
    asChild?: boolean;
}
export interface SheetStackOutletProps extends React.HTMLAttributes<HTMLElement> {
    forComponent?: SheetStackId | "closest";
    stackingAnimation?: StackingAnimationPropValue;
    asChild?: boolean;
    children: React.ReactNode;
}
export const SheetStack: {
    Root: React.ForwardRefExoticComponent<SheetStackRootProps & React.RefAttributes<any>>;
    Outlet: React.ForwardRefExoticComponent<SheetStackOutletProps & React.RefAttributes<any>>;
};
type Scrollhandler = ({ progress, distance, availableDistance, nativeEvent, }: {
    progress: number;
    distance: number;
    availableDistance: number;
    nativeEvent: React.UIEvent<HTMLDivElement>;
}) => void;
interface ScrollToOptions {
    progress?: number;
    distance?: number;
    animationSettings?: {
        skip: "default" | "auto" | boolean;
    };
}
interface ScrollByOptions {
    progress?: number;
    distance?: number;
    animationSettings?: {
        skip: "default" | "auto" | boolean;
    };
}
interface ScrollRef {
    getProgress: () => number;
    getDistance: () => number;
    getAvailableDistance: () => number;
    scrollTo: (options: ScrollToOptions) => void;
    scrollBy: (options: ScrollByOptions) => void;
}
export interface ScrollRootProps extends React.HTMLAttributes<HTMLDivElement> {
    asChild?: boolean;
    componentId?: ScrollId;
    componentRef?: React.RefObject<ScrollRef>;
    "data-silk"?: string;
}
type ScrollAxis = "x" | "y";
type ScrollViewFocusInsideCustomEvent = {
    scrollIntoView: boolean;
    nativeEvent: Event;
    changeDefault: (changedBehavior: {
        scrollIntoView: boolean;
    }) => void;
};
type ScrollViewScrollStartCustomEvent = {
    dismissKeyboard: boolean;
    nativeEvent: Event;
    changeDefault: (changedBehavior: {
        dismissKeyboard: boolean;
    }) => void;
};
type ScrollViewScrollEndCustomEvent = {
    nativeEvent: Event;
};
export interface ScrollViewProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onScroll"> {
    asChild?: boolean;
    "data-silk"?: string;
    forComponent?: ScrollId;
    axis?: ScrollAxis;
    pageScroll?: boolean;
    nativePageScrollReplacement?: "auto" | boolean;
    safeArea?: SafeArea;
    scrollGestureTrap?: boolean | {
        x?: boolean;
        y?: boolean;
    } | {
        xStart?: boolean;
        xEnd?: boolean;
        yStart?: boolean;
        yEnd?: boolean;
    };
    scrollGestureOvershoot?: boolean;
    scrollGesture?: "auto" | false;
    onScroll?: Scrollhandler;
    onScrollStart?: {
        dismissKeyboard: boolean;
    } | ((customEvent: ScrollViewScrollStartCustomEvent) => void);
    onScrollEnd?: (customEvent: ScrollViewScrollEndCustomEvent) => void;
    onFocusInside?: {
        scrollIntoView: boolean;
    } | ((customEvent: ScrollViewFocusInsideCustomEvent) => void);
    nativeFocusScrollPrevention?: boolean;
    scrollAnimationSettings?: {
        skip: "auto" | boolean;
    };
    scrollAnchoring?: boolean;
    scrollSnapType?: "none" | "proximity" | "mandatory";
    scrollPadding?: string;
    scrollTimelineName?: string;
    nativeScrollbar?: boolean;
}
export interface ScrollContentProps extends React.HTMLAttributes<HTMLDivElement> {
    asChild?: boolean;
    "data-silk"?: string;
}
interface _TriggerPressHandlerOptions1 {
    forceFocus?: boolean;
    runAction?: boolean;
}
interface _TriggerPressCustomEvent1 extends _TriggerPressHandlerOptions1 {
    nativeEvent: React.MouseEvent<HTMLElement, MouseEvent>;
    changeDefault: (changedBehavior: _TriggerPressHandlerOptions1) => void;
}
type _TriggerPressHandlerValue1 = _TriggerPressHandlerOptions1 | ((customEvent: _TriggerPressCustomEvent1) => void);
interface ScrollTriggerAction {
    type: "scroll-to" | "scroll-by";
    progress?: number;
    distance?: number;
    animationSettings?: {
        skip: "default" | "auto" | boolean;
    };
}
interface TriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
    forComponent?: ScrollId;
    asChild?: boolean;
    action?: ScrollTriggerAction;
    onPress?: _TriggerPressHandlerValue1;
    onClick?: (e: React.MouseEvent<HTMLElement>) => void;
}
export const Scroll: {
    Root: React.ForwardRefExoticComponent<ScrollRootProps & React.RefAttributes<any>>;
    Trigger: React.ForwardRefExoticComponent<TriggerProps & React.RefAttributes<unknown>>;
    View: React.ForwardRefExoticComponent<ScrollViewProps & React.RefAttributes<any>>;
    Content: React.ForwardRefExoticComponent<ScrollContentProps & React.RefAttributes<any>>;
};
export interface AutoFocusTargetRootProps extends React.HTMLAttributes<HTMLDivElement> {
    asChild?: boolean;
    "data-silk"?: string;
    forComponent?: SheetId;
    timing: "present" | "dismiss" | Array<"present" | "dismiss">;
}
export const AutoFocusTarget: {
    Root: React.ForwardRefExoticComponent<AutoFocusTargetRootProps & React.RefAttributes<unknown>>;
};
type MutuallyExclusiveProps = {
    children: React.ReactNode;
    contentGetter: (() => HTMLElement | Element | null | undefined) | string;
};
type PickOne<T, F extends keyof T> = Pick<T, F> & {
    [K in keyof Omit<T, F>]?: never;
};
type PickedProp<E> = E extends keyof MutuallyExclusiveProps ? PickOne<MutuallyExclusiveProps, E> : never;
export type IslandRootProps = React.HTMLAttributes<HTMLDivElement> & PickedProp<keyof MutuallyExclusiveProps> & {
    asChild?: boolean;
    disabled?: boolean;
    forComponent?: SheetId | SheetStackId | Array<SheetId | SheetStackId>;
};
export interface IslandContentProps extends React.HTMLAttributes<HTMLDivElement> {
    asChild?: boolean;
    "data-silk"?: string;
}
export const Island: {
    Root: React.ForwardRefExoticComponent<IslandRootProps & React.RefAttributes<any>>;
    Content: React.ForwardRefExoticComponent<IslandContentProps & React.RefAttributes<any>>;
};
type _MutuallyExclusiveProps1 = {
    children: React.ReactNode;
    contentGetter: (() => HTMLElement | Element | null | undefined) | string;
};
type _PickOne1<T, F extends keyof T> = Pick<T, F> & {
    [K in keyof Omit<T, F>]?: never;
};
type _PickedProp1<E> = E extends keyof _MutuallyExclusiveProps1 ? _PickOne1<_MutuallyExclusiveProps1, E> : never;
export type ExternalOverlayRootProps = React.HTMLAttributes<HTMLElement> & _PickedProp1<keyof _MutuallyExclusiveProps1> & {
    asChild?: boolean;
    disabled?: boolean;
    selfManagedInertOutside?: boolean;
};
export const ExternalOverlay: {
    Root: React.ForwardRefExoticComponent<ExternalOverlayRootProps & React.RefAttributes<unknown>>;
};
export const createComponentId: () => ComponentId;
export const useClientMediaQuery: (value: string) => boolean;
export const useThemeColorDimmingOverlay: ({ elementRef, dimmingColor, }: {
    elementRef?: import("react").RefObject<HTMLElement> | undefined;
    dimmingColor: string;
}) => {
    setDimmingOverlayOpacity: (alpha: number) => void;
    animateDimmingOverlayOpacity: ({ keyframes, duration, easing, }: {
        keyframes: [number, number];
        duration?: number | undefined;
        easing?: string | undefined;
    }) => void;
};
export const usePageScrollData: () => any;
export const animate: (element: HTMLElement | null, keyframes: {
    [keys: string]: [string | number, string | number];
}, options?: {
    duration?: number;
    easing?: string;
}) => void;

//# sourceMappingURL=types.d.ts.map