@hanzogui/sheet 2.0.0

package/types/createSheet.d.ts

@@ -0,0 +1,194 @@
+import type { GetProps, ViewProps, GuiComponent, GuiComponentExpectingVariants } from '@gui/core';
+import type { ForwardRefExoticComponent, FunctionComponent, RefAttributes } from 'react';
+import type { View as RNView } from 'react-native';
+import type { SheetProps, SheetScopedProps } from './types';
+type SharedSheetProps = {
+    open?: boolean;
+};
+type BaseProps = ViewProps & SharedSheetProps;
+type SheetStyledComponent = GuiComponentExpectingVariants<BaseProps, SharedSheetProps>;
+export declare function createSheet<H extends GuiComponent | SheetStyledComponent, F extends GuiComponent | SheetStyledComponent, O extends GuiComponent | SheetStyledComponent>({ Handle, Frame, Overlay }: {
+    Handle: H;
+    Frame: F;
+    Overlay: O;
+}): ForwardRefExoticComponent<{
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: import("react").Dispatch<import("react").SetStateAction<boolean>> | ((open: boolean) => void);
+    position?: number;
+    defaultPosition?: number;
+    snapPoints?: (string | number)[];
+    snapPointsMode?: import("./types").SnapPointsMode;
+    onPositionChange?: import("./types").PositionChangeHandler;
+    children?: import("react").ReactNode;
+    dismissOnOverlayPress?: boolean;
+    dismissOnSnapToBottom?: boolean;
+    disableRemoveScroll?: boolean;
+    forceRemoveScrollEnabled?: boolean;
+    transitionConfig?: import("@gui/core").AnimatedNumberStrategy;
+    preferAdaptParentOpenState?: boolean;
+    unmountChildrenWhenHidden?: boolean;
+    native?: "ios"[] | boolean;
+    transition?: import("@gui/core").TransitionProp;
+    handleDisableScroll?: boolean;
+    disableDrag?: boolean;
+    modal?: boolean;
+    zIndex?: number;
+    portalProps?: import("@gui/portal").PortalProps;
+    moveOnKeyboardChange?: boolean;
+    containerComponent?: React.ComponentType<any>;
+    onAnimationComplete?: (info: {
+        open: boolean;
+    }) => void;
+} & {
+    __scopeSheet?: import("@gui/create-context").Scope<any>;
+} & RefAttributes<RNView>> & {
+    Controlled: FunctionComponent<Omit<SheetProps, "open" | "onOpenChange"> & RefAttributes<RNView>> & {
+        Frame: ForwardRefExoticComponent<SheetScopedProps<Omit<GetProps<F>, keyof {
+            /**
+             * By default the sheet adds a view below its bottom that extends down another 50%,
+             * this is useful if your Sheet has a spring animation that bounces "past" the top when
+             * opening, preventing it from showing the content underneath.
+             */
+            disableHideBottomOverflow?: boolean;
+            /**
+             * Adds padding accounting for the currently offscreen content, so if you put a flex element inside
+             * the sheet, it will always flex to the height of the visible amount of the sheet. If this is not
+             * turned on, the inner content is always set to the max height of the sheet.
+             */
+            adjustPaddingForOffscreenContent?: boolean;
+        }> & {
+            /**
+             * By default the sheet adds a view below its bottom that extends down another 50%,
+             * this is useful if your Sheet has a spring animation that bounces "past" the top when
+             * opening, preventing it from showing the content underneath.
+             */
+            disableHideBottomOverflow?: boolean;
+            /**
+             * Adds padding accounting for the currently offscreen content, so if you put a flex element inside
+             * the sheet, it will always flex to the height of the visible amount of the sheet. If this is not
+             * turned on, the inner content is always set to the max height of the sheet.
+             */
+            adjustPaddingForOffscreenContent?: boolean;
+        }>>;
+        Overlay: GuiComponent<Omit<BaseProps, "__scopeSheet"> & {
+            __scopeSheet?: import("@gui/create-context").Scope<any>;
+        }, any, any, any, SharedSheetProps, {}> | GuiComponent<Omit<BaseProps, "__scopeSheet"> & {
+            __scopeSheet?: import("@gui/create-context").Scope<any>;
+        }, any, {
+            __scopeSheet?: import("@gui/create-context").Scope<any>;
+        }, {}, {}, {}>;
+        Handle: GuiComponent<any, any, any, any, SharedSheetProps, {}> | GuiComponent<any, any, any, {}, {}, {}>;
+        ScrollView: ForwardRefExoticComponent<Omit<import("@gui/core").GuiComponentPropsBaseBase & import("react-native").ScrollViewProps, keyof import("@gui/core").StackStyleBase | "fullscreen" | "contentContainerStyle"> & import("@gui/core").WithThemeValues<import("@gui/core").StackStyleBase & {
+            readonly contentContainerStyle?: Partial<import("@gui/core").InferStyleProps<typeof import("react-native").ScrollView, {
+                accept: {
+                    readonly contentContainerStyle: "style";
+                };
+            }>> | undefined;
+        }> & {
+            fullscreen?: boolean | undefined;
+        } & import("@gui/core").WithShorthands<import("@gui/core").WithThemeValues<import("@gui/core").StackStyleBase & {
+            readonly contentContainerStyle?: Partial<import("@gui/core").InferStyleProps<typeof import("react-native").ScrollView, {
+                accept: {
+                    readonly contentContainerStyle: "style";
+                };
+            }>> | undefined;
+        }>> & import("@gui/core").WithPseudoProps<import("@gui/core").WithThemeValues<import("@gui/core").StackStyleBase & {
+            readonly contentContainerStyle?: Partial<import("@gui/core").InferStyleProps<typeof import("react-native").ScrollView, {
+                accept: {
+                    readonly contentContainerStyle: "style";
+                };
+            }>> | undefined;
+        }> & {
+            fullscreen?: boolean | undefined;
+        } & import("@gui/core").WithShorthands<import("@gui/core").WithThemeValues<import("@gui/core").StackStyleBase & {
+            readonly contentContainerStyle?: Partial<import("@gui/core").InferStyleProps<typeof import("react-native").ScrollView, {
+                accept: {
+                    readonly contentContainerStyle: "style";
+                };
+            }>> | undefined;
+        }>>> & import("@gui/core").WithMediaProps<import("@gui/core").WithThemeShorthandsAndPseudos<import("@gui/core").StackStyleBase & {
+            readonly contentContainerStyle?: Partial<import("@gui/core").InferStyleProps<typeof import("react-native").ScrollView, {
+                accept: {
+                    readonly contentContainerStyle: "style";
+                };
+            }>> | undefined;
+        }, {
+            fullscreen?: boolean | undefined;
+        }>> & RefAttributes<import("react-native").ScrollView>>;
+    };
+    Frame: ForwardRefExoticComponent<SheetScopedProps<Omit<GetProps<F>, keyof {
+        /**
+         * By default the sheet adds a view below its bottom that extends down another 50%,
+         * this is useful if your Sheet has a spring animation that bounces "past" the top when
+         * opening, preventing it from showing the content underneath.
+         */
+        disableHideBottomOverflow?: boolean;
+        /**
+         * Adds padding accounting for the currently offscreen content, so if you put a flex element inside
+         * the sheet, it will always flex to the height of the visible amount of the sheet. If this is not
+         * turned on, the inner content is always set to the max height of the sheet.
+         */
+        adjustPaddingForOffscreenContent?: boolean;
+    }> & {
+        /**
+         * By default the sheet adds a view below its bottom that extends down another 50%,
+         * this is useful if your Sheet has a spring animation that bounces "past" the top when
+         * opening, preventing it from showing the content underneath.
+         */
+        disableHideBottomOverflow?: boolean;
+        /**
+         * Adds padding accounting for the currently offscreen content, so if you put a flex element inside
+         * the sheet, it will always flex to the height of the visible amount of the sheet. If this is not
+         * turned on, the inner content is always set to the max height of the sheet.
+         */
+        adjustPaddingForOffscreenContent?: boolean;
+    }>>;
+    Overlay: GuiComponent<Omit<BaseProps, "__scopeSheet"> & {
+        __scopeSheet?: import("@gui/create-context").Scope<any>;
+    }, any, any, any, SharedSheetProps, {}> | GuiComponent<Omit<BaseProps, "__scopeSheet"> & {
+        __scopeSheet?: import("@gui/create-context").Scope<any>;
+    }, any, {
+        __scopeSheet?: import("@gui/create-context").Scope<any>;
+    }, {}, {}, {}>;
+    Handle: GuiComponent<any, any, any, any, SharedSheetProps, {}> | GuiComponent<any, any, any, {}, {}, {}>;
+    ScrollView: ForwardRefExoticComponent<Omit<import("@gui/core").GuiComponentPropsBaseBase & import("react-native").ScrollViewProps, keyof import("@gui/core").StackStyleBase | "fullscreen" | "contentContainerStyle"> & import("@gui/core").WithThemeValues<import("@gui/core").StackStyleBase & {
+        readonly contentContainerStyle?: Partial<import("@gui/core").InferStyleProps<typeof import("react-native").ScrollView, {
+            accept: {
+                readonly contentContainerStyle: "style";
+            };
+        }>> | undefined;
+    }> & {
+        fullscreen?: boolean | undefined;
+    } & import("@gui/core").WithShorthands<import("@gui/core").WithThemeValues<import("@gui/core").StackStyleBase & {
+        readonly contentContainerStyle?: Partial<import("@gui/core").InferStyleProps<typeof import("react-native").ScrollView, {
+            accept: {
+                readonly contentContainerStyle: "style";
+            };
+        }>> | undefined;
+    }>> & import("@gui/core").WithPseudoProps<import("@gui/core").WithThemeValues<import("@gui/core").StackStyleBase & {
+        readonly contentContainerStyle?: Partial<import("@gui/core").InferStyleProps<typeof import("react-native").ScrollView, {
+            accept: {
+                readonly contentContainerStyle: "style";
+            };
+        }>> | undefined;
+    }> & {
+        fullscreen?: boolean | undefined;
+    } & import("@gui/core").WithShorthands<import("@gui/core").WithThemeValues<import("@gui/core").StackStyleBase & {
+        readonly contentContainerStyle?: Partial<import("@gui/core").InferStyleProps<typeof import("react-native").ScrollView, {
+            accept: {
+                readonly contentContainerStyle: "style";
+            };
+        }>> | undefined;
+    }>>> & import("@gui/core").WithMediaProps<import("@gui/core").WithThemeShorthandsAndPseudos<import("@gui/core").StackStyleBase & {
+        readonly contentContainerStyle?: Partial<import("@gui/core").InferStyleProps<typeof import("react-native").ScrollView, {
+            accept: {
+                readonly contentContainerStyle: "style";
+            };
+        }>> | undefined;
+    }, {
+        fullscreen?: boolean | undefined;
+    }>> & RefAttributes<import("react-native").ScrollView>>;
+};
+export {};
+//# sourceMappingURL=createSheet.d.ts.map

package/types/gestureState.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Re-export gesture state from @gui/native.
+ * Sheet uses this for backward compatibility with existing code.
+ */
+import { type GestureState } from '@gui/native';
+export type { GestureState as GestureHandlerState } from '@gui/native';
+export declare function isGestureHandlerEnabled(): boolean;
+export declare function getGestureHandlerState(): GestureState;
+export declare function setGestureHandlerState(updates: Partial<GestureState>): void;
+export declare const setGestureState: typeof setGestureHandlerState;
+//# sourceMappingURL=gestureState.d.ts.map

package/types/helpers.d.ts

@@ -0,0 +1,2 @@
+export declare function resisted(y: number, minY: number, maxOverflow?: number): number;
+//# sourceMappingURL=helpers.d.ts.map

package/types/index.d.ts

@@ -0,0 +1,12 @@
+export * from './Sheet';
+export * from './useSheet';
+export * from './createSheet';
+export * from './SheetController';
+export * from './useSheetController';
+export * from './useSheetOpenState';
+export * from './useSheetOffscreenSize';
+export * from './SheetScrollView';
+export * from './nativeSheet';
+export * from './types';
+export * from './contexts';
+//# sourceMappingURL=index.d.ts.map

package/types/nativeSheet.d.ts

@@ -0,0 +1,10 @@
+import type { FunctionComponent } from 'react';
+import type { SheetProps } from './types';
+type SheetNativePlatforms = 'ios';
+export declare function getNativeSheet(platform: SheetNativePlatforms): FunctionComponent<SheetProps> | null;
+export declare function setupNativeSheet(platform: SheetNativePlatforms, RNIOSModal: {
+    ModalSheetView: any;
+    ModalSheetViewMainContent: any;
+}): void;
+export {};
+//# sourceMappingURL=nativeSheet.d.ts.map

package/types/setupGestureHandler.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Legacy setup - prefer `import '@gui/native/setup-gesture-handler'` instead.
+ */
+export declare function isGestureHandlerEnabled(): boolean;
+export interface SetupGestureHandlerConfig {
+    Gesture: any;
+    GestureDetector: any;
+    ScrollView?: any;
+}
+export declare function setupGestureHandler(config: SetupGestureHandlerConfig): void;
+//# sourceMappingURL=setupGestureHandler.d.ts.map

package/types/types.d.ts

@@ -0,0 +1,147 @@
+import type { AnimatedNumberStrategy, TransitionProp } from '@gui/core';
+import type { ScopedProps } from '@gui/create-context';
+import type { PortalProps } from '@gui/portal';
+import type { RemoveScroll } from '@gui/remove-scroll';
+import type { ReactNode } from 'react';
+import type React from 'react';
+export type SheetProps = ScopedProps<{
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: OpenChangeHandler;
+    /**
+     * Control the index of the position in the `snapPoints` array
+     */
+    position?: number;
+    /**
+     * Initial position from the `snapPoints` array
+     */
+    defaultPosition?: number;
+    /**
+     * Array of pixels or percents the Sheet will attempt to move to when dragged.
+     * The first is the topmost and default when first opened via open prop.
+     */
+    snapPoints?: (string | number)[];
+    snapPointsMode?: SnapPointsMode;
+    onPositionChange?: PositionChangeHandler;
+    children?: ReactNode;
+    dismissOnOverlayPress?: boolean;
+    dismissOnSnapToBottom?: boolean;
+    /**
+     * Disables the RemoveScroll behavior that prevents body scrolling while sheet is open.
+     * By default, RemoveScroll is enabled when the sheet is open and modal.
+     */
+    disableRemoveScroll?: boolean;
+    /**
+     * @deprecated Use `disableRemoveScroll` instead. This prop will be removed in a future version.
+     * Note: `disableRemoveScroll={true}` is equivalent to `forceRemoveScrollEnabled={false}`
+     */
+    forceRemoveScrollEnabled?: boolean;
+    transitionConfig?: AnimatedNumberStrategy;
+    /**
+     * By default Sheet will prefer the open prop over a parent component that is
+     * controlling it via Adapt. In general if you want to Adapt to a sheet, you'd
+     * leave the open prop undefined. If you'd like to have the parent override the
+     * prop you've set manually on Sheet, set this to true.
+     */
+    preferAdaptParentOpenState?: boolean;
+    /**
+     * (experimental) Remove the children while hidden (to save some performance, but can cause issues with animations)
+     */
+    unmountChildrenWhenHidden?: boolean;
+    /**
+     * Adapts the sheet to use native sheet on the given platform (if available)
+     */
+    native?: 'ios'[] | boolean;
+    /**
+     * Pass if you're using the CSS animation driver
+     */
+    transition?: TransitionProp;
+    handleDisableScroll?: boolean;
+    disableDrag?: boolean;
+    modal?: boolean;
+    zIndex?: number;
+    portalProps?: PortalProps;
+    /**
+     * Native-only flag that will make the sheet move up when the mobile keyboard opens so the focused input remains visible
+     */
+    moveOnKeyboardChange?: boolean;
+    containerComponent?: React.ComponentType<any>;
+    /**
+     * Called when the sheet open/close animation completes.
+     */
+    onAnimationComplete?: (info: {
+        open: boolean;
+    }) => void;
+}, 'Sheet'>;
+export type PositionChangeHandler = (position: number) => void;
+type OpenChangeHandler = ((open: boolean) => void) | React.Dispatch<React.SetStateAction<boolean>>;
+export type RemoveScrollProps = React.ComponentProps<typeof RemoveScroll>;
+export type SnapPointsMode = 'percent' | 'constant' | 'fit' | 'mixed';
+export type SheetScopedProps<A> = ScopedProps<A, 'Sheet'>;
+export type ScrollBridge = {
+    enabled: boolean;
+    y: number;
+    paneY: number;
+    paneMinY: number;
+    scrollStartY: number;
+    hasScrollableContent: boolean;
+    drag: (dy: number) => void;
+    release: (state: {
+        dragAt: number;
+        vy: number;
+    }) => void;
+    scrollLock: boolean;
+    isParentDragging: boolean;
+    onParentDragging: (props: (val: boolean) => void) => () => void;
+    setParentDragging: (val: boolean) => void;
+    onFinishAnimate?: () => void;
+    blockPan?: boolean;
+    initialPosition?: number;
+    isScrollablePositionLocked?: boolean;
+    setScrollEnabled?: (enabled: boolean, lockTo?: number) => void;
+    _lastTouchY?: number;
+    scrollLockY?: number;
+    forceScrollTo?: (y: number) => void;
+    isAtTop?: boolean;
+    snapToPosition?: (positionIndex: number) => void;
+};
+export interface KeyboardControllerSheetOptions {
+    /**
+     * Whether keyboard handling is enabled.
+     * When false, the hook is a no-op.
+     */
+    enabled: boolean;
+}
+export interface KeyboardControllerSheetResult {
+    /**
+     * Whether keyboard-controller is available and enabled.
+     */
+    keyboardControllerEnabled: boolean;
+    /**
+     * Current keyboard height (0 when hidden).
+     * On web or when keyboard-controller is not available, always 0.
+     */
+    keyboardHeight: number;
+    /**
+     * Whether the keyboard is currently visible.
+     */
+    isKeyboardVisible: boolean;
+    /**
+     * Dismiss the keyboard programmatically.
+     * Called when sheet closes to dismiss the keyboard.
+     */
+    dismissKeyboard: () => void;
+    /**
+     * Ref to pause keyboard hide state updates (action-sheet pattern).
+     * When true, keyboard hide events are ignored — keeps isKeyboardVisible=true
+     * and keyboardHeight at their last values during drag.
+     */
+    pauseKeyboardHandler: React.RefObject<boolean>;
+    /**
+     * Flush any keyboard hide event that was suppressed while paused.
+     * Call after drag ends to reconcile actual keyboard state.
+     */
+    flushPendingHide: () => void;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/types/useGestureHandlerPan.d.ts

@@ -0,0 +1,44 @@
+import { type RefObject } from 'react';
+import type { ScrollBridge } from './types';
+interface GesturePanConfig {
+    positions: number[];
+    frameSize: number;
+    setPosition: (pos: number) => void;
+    animateTo: (pos: number, animationOverride?: any) => void;
+    stopSpring: () => void;
+    scrollBridge: ScrollBridge;
+    setIsDragging: (val: boolean) => void;
+    getCurrentPosition: () => number;
+    resisted: (val: number, minY: number) => number;
+    disableDrag?: boolean;
+    isShowingInnerSheet?: boolean;
+    setAnimatedPosition: (val: number) => void;
+    scrollGestureRef?: RefObject<any> | null;
+    pauseKeyboardHandler?: RefObject<boolean>;
+}
+interface GesturePanResult {
+    panGesture: any | null;
+    panGestureRef: RefObject<any>;
+    gestureHandlerEnabled: boolean;
+}
+/**
+ * Hook that creates a Gesture.Pan() handler for use with react-native-gesture-handler.
+ * This provides native-quality gesture coordination between Sheet and ScrollView.
+ *
+ * Uses state-based decision pattern (like gorhom/bottom-sheet and react-native-actions-sheet):
+ * - Both pan and scroll gestures run simultaneously
+ * - In onChange, we decide whether to process pan or let scroll handle it
+ * - scrollBridge.setScrollEnabled toggles scroll on/off as needed
+ *
+ * Decision matrix:
+ * 1. Sheet not fully open + swiping up -> pan handles (disable scroll)
+ * 2. Sheet fully open + swiping up -> scroll handles (blockPan)
+ * 3. Sheet not fully open + swiping down -> pan handles (unless scrolled)
+ * 4. Sheet fully open + swiping down + scrollY=0 -> pan handles
+ * 5. Sheet fully open + swiping down + scrollY>0 -> scroll handles (blockPan)
+ *
+ * Returns null for the gesture if RNGH is not available or drag is disabled.
+ */
+export declare function useGestureHandlerPan(config: GesturePanConfig): GesturePanResult;
+export {};
+//# sourceMappingURL=useGestureHandlerPan.d.ts.map

package/types/useKeyboardControllerSheet.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Web stub for keyboard controller sheet hook.
+ * Returns no-op values since keyboard-controller is native-only.
+ */
+import type { KeyboardControllerSheetOptions, KeyboardControllerSheetResult } from './types';
+export declare function useKeyboardControllerSheet(_options: KeyboardControllerSheetOptions): KeyboardControllerSheetResult;
+//# sourceMappingURL=useKeyboardControllerSheet.d.ts.map

package/types/useKeyboardControllerSheet.native.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Native implementation of keyboard controller sheet hook.
+ *
+ * Simplified to just track keyboard state (height, visibility).
+ * Position animation is handled by SheetImplementationCustom via
+ * keyboard-adjusted positions — matching the react-native-actions-sheet pattern.
+ *
+ * Uses react-native-keyboard-controller events when available,
+ * falls back to basic Keyboard API otherwise.
+ */
+import type { KeyboardControllerSheetOptions, KeyboardControllerSheetResult } from './types';
+export declare function useKeyboardControllerSheet(options: KeyboardControllerSheetOptions): KeyboardControllerSheetResult;
+//# sourceMappingURL=useKeyboardControllerSheet.native.d.ts.map

package/types/useSheet.d.ts

@@ -0,0 +1,2 @@
+export declare const useSheet: () => import("./useSheetProviderProps").SheetContextValue;
+//# sourceMappingURL=useSheet.d.ts.map

package/types/useSheetController.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+export declare const useSheetController: () => {
+    controller: SheetControllerContextValue | null;
+    isHidden: boolean | undefined;
+    isShowingNonSheet: boolean | undefined;
+    disableDrag: boolean | undefined;
+};
+export declare const SheetControllerContext: React.Context<SheetControllerContextValue | null>;
+export type SheetControllerContextValue = {
+    id?: string;
+    disableDrag?: boolean;
+    open?: boolean;
+    hidden?: boolean;
+    onOpenChange?: React.Dispatch<React.SetStateAction<boolean>> | ((val: boolean) => void);
+    skipNextAnimation?: boolean;
+};
+//# sourceMappingURL=useSheetController.d.ts.map

package/types/useSheetOffscreenSize.d.ts

@@ -0,0 +1,3 @@
+import type { SheetContextValue } from './useSheetProviderProps';
+export declare const useSheetOffscreenSize: ({ snapPoints, position, screenSize, frameSize, snapPointsMode, }: SheetContextValue) => number;
+//# sourceMappingURL=useSheetOffscreenSize.d.ts.map

package/types/useSheetOpenState.d.ts

@@ -0,0 +1,9 @@
+import type { SheetProps } from './types';
+export declare const useSheetOpenState: (props: SheetProps) => {
+    open: boolean;
+    setOpen: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    isHidden: boolean | undefined;
+    controller: import("./useSheetController").SheetControllerContextValue | null;
+};
+export type SheetOpenState = ReturnType<typeof useSheetOpenState>;
+//# sourceMappingURL=useSheetOpenState.d.ts.map

package/types/useSheetProviderProps.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+import type { GuiElement } from '@gui/core';
+import type { ScrollBridge, SheetProps } from './types';
+import type { SheetOpenState } from './useSheetOpenState';
+export type SheetContextValue = ReturnType<typeof useSheetProviderProps> & {
+    setHasScrollView: (val: boolean) => void;
+};
+export declare function useSheetProviderProps(props: SheetProps, state: SheetOpenState, options?: {
+    onOverlayComponent?: (comp: any) => void;
+}): {
+    screenSize: number;
+    maxSnapPoint: string | number;
+    disableRemoveScroll: boolean;
+    scrollBridge: ScrollBridge;
+    modal: boolean;
+    open: boolean;
+    setOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    hidden: boolean;
+    contentRef: React.RefObject<GuiElement | null>;
+    handleRef: React.RefObject<GuiElement | null>;
+    frameSize: number;
+    setFrameSize: React.Dispatch<React.SetStateAction<number>>;
+    dismissOnOverlayPress: boolean;
+    dismissOnSnapToBottom: boolean;
+    onOverlayComponent: ((comp: any) => void) | undefined;
+    scope: import("@gui/create-context").Scope<any>;
+    hasFit: boolean;
+    position: number;
+    snapPoints: (string | number)[];
+    snapPointsMode: import("./types").SnapPointsMode;
+    setMaxContentSize: React.Dispatch<React.SetStateAction<number>>;
+    setPosition: (next: number) => void;
+    setPositionImmediate: React.Dispatch<React.SetStateAction<number>>;
+    onlyShowFrame: boolean;
+};
+//# sourceMappingURL=useSheetProviderProps.d.ts.map

package/types/useSheetScrollViewGestures.d.ts

@@ -0,0 +1,12 @@
+import type { ScrollView as RNScrollView } from 'react-native';
+import type { ScrollBridge } from './types';
+interface UseSheetScrollViewGesturesProps {
+    scrollRef: React.RefObject<RNScrollView | null>;
+    scrollBridge: ScrollBridge;
+    hasScrollableContent: boolean;
+    scrollEnabled: boolean;
+    setScrollEnabled: (enabled: boolean, lockTo?: number) => void;
+}
+export declare function useSheetScrollViewGestures({ scrollRef, scrollBridge, hasScrollableContent, }: UseSheetScrollViewGesturesProps): {};
+export {};
+//# sourceMappingURL=useSheetScrollViewGestures.d.ts.map

package/types/useSheetScrollViewGestures.native.d.ts

@@ -0,0 +1,21 @@
+import type { GestureResponderEvent, ScrollView as RNScrollView } from 'react-native';
+import type { ScrollBridge } from './types';
+interface UseSheetScrollViewGesturesProps {
+    scrollRef: React.RefObject<RNScrollView | null>;
+    scrollBridge: ScrollBridge;
+    hasScrollableContent: boolean;
+    scrollEnabled: boolean;
+    setScrollEnabled: (enabled: boolean, lockTo?: number) => void;
+}
+/**
+ * Native gesture handling for Sheet ScrollView.
+ * Returns responder props for the ScrollView component.
+ */
+export declare function useSheetScrollViewGestures({ scrollBridge, hasScrollableContent, scrollEnabled, setScrollEnabled, }: UseSheetScrollViewGesturesProps): {
+    onResponderRelease: () => void;
+    onStartShouldSetResponder: () => boolean;
+    onMoveShouldSetResponder: (e: GestureResponderEvent) => boolean;
+    onResponderMove: (e: GestureResponderEvent) => void;
+};
+export {};
+//# sourceMappingURL=useSheetScrollViewGestures.native.d.ts.map