react-native-keyboard-controller 1.17.1 → 1.17.2

package/lib/typescript/components/KeyboardAvoidingView/index.d.ts

@@ -33,8 +33,17 @@ export type KeyboardAvoidingViewProps = KeyboardAvoidingViewBaseProps & ({
     contentContainerStyle?: never;
 });
 /**
- * View that moves out of the way when the keyboard appears by automatically
- * adjusting its height, position, or bottom padding.
+ * A View component that automatically adjusts its height, position, or bottom padding
+ * when the keyboard appears to ensure that the content remains visible.
+ *
+ * @returns A View component that adjusts to keyboard visibility.
+ * @see {@link https://kirillzyusko.github.io/react-native-keyboard-controller/docs/api/components/keyboard-avoiding-view|Documentation} page for more details.
+ * @example
+ * ```tsx
+ * <KeyboardAvoidingView behavior="padding">
+ *   <TextInput />
+ * </KeyboardAvoidingView>
+ * ```
  */
 declare const KeyboardAvoidingView: React.ForwardRefExoticComponent<React.PropsWithChildren<KeyboardAvoidingViewProps> & React.RefAttributes<View>>;
 export default KeyboardAvoidingView;

package/lib/typescript/components/KeyboardAwareScrollView/index.d.ts

@@ -5,23 +5,40 @@ export type KeyboardAwareScrollViewProps = {
     bottomOffset?: number;
     /** Prevents automatic scrolling of the `ScrollView` when the keyboard gets hidden, maintaining the current screen position. Default is `false`. */
     disableScrollOnKeyboardHide?: boolean;
-    /** Controls whether this `KeyboardAwareScrollView` instance should take effect. Default is `true` */
+    /** Controls whether this `KeyboardAwareScrollView` instance should take effect. Default is `true`. */
     enabled?: boolean;
-    /** Adjusting the bottom spacing of KeyboardAwareScrollView. Default is `0` */
+    /** Adjusting the bottom spacing of KeyboardAwareScrollView. Default is `0`. */
     extraKeyboardSpace?: number;
-    /** Custom component for `ScrollView`. Default is `ScrollView` */
+    /** Custom component for `ScrollView`. Default is `ScrollView`. */
     ScrollViewComponent?: React.ComponentType<ScrollViewProps>;
 } & ScrollViewProps;
+/**
+ * A ScrollView component that automatically handles keyboard appearance and disappearance
+ * by adjusting its content position to ensure the focused input remains visible.
+ *
+ * The component uses a sophisticated animation system to smoothly handle keyboard transitions
+ * and maintain proper scroll position during keyboard interactions.
+ *
+ * @returns A ScrollView component that handles keyboard interactions.
+ * @see {@link https://kirillzyusko.github.io/react-native-keyboard-controller/docs/api/components/keyboard-aware-scroll-view|Documentation} page for more details.
+ * @example
+ * ```tsx
+ * <KeyboardAwareScrollView bottomOffset={20}>
+ *   <TextInput placeholder="Enter text" />
+ *   <TextInput placeholder="Another input" />
+ * </KeyboardAwareScrollView>
+ * ```
+ */
 declare const KeyboardAwareScrollView: React.ForwardRefExoticComponent<{
     /** The distance between keyboard and focused `TextInput` when keyboard is shown. Default is `0`. */
     bottomOffset?: number;
     /** Prevents automatic scrolling of the `ScrollView` when the keyboard gets hidden, maintaining the current screen position. Default is `false`. */
     disableScrollOnKeyboardHide?: boolean;
-    /** Controls whether this `KeyboardAwareScrollView` instance should take effect. Default is `true` */
+    /** Controls whether this `KeyboardAwareScrollView` instance should take effect. Default is `true`. */
     enabled?: boolean;
-    /** Adjusting the bottom spacing of KeyboardAwareScrollView. Default is `0` */
+    /** Adjusting the bottom spacing of KeyboardAwareScrollView. Default is `0`. */
     extraKeyboardSpace?: number;
-    /** Custom component for `ScrollView`. Default is `ScrollView` */
+    /** Custom component for `ScrollView`. Default is `ScrollView`. */
     ScrollViewComponent?: React.ComponentType<ScrollViewProps>;
 } & ScrollViewProps & {
     children?: React.ReactNode | undefined;

package/lib/typescript/components/KeyboardAwareScrollView/useSmoothKeyboardHandler.d.ts

@@ -1,6 +1,22 @@
 import { useKeyboardHandler } from "../../hooks";
 /**
  * Hook that uses default transitions for iOS and Android > 11, and uses
- * custom interpolation on Android < 11 to achieve more smooth animation
+ * custom interpolation on Android < 11 to achieve more smooth animation.
+ *
+ * @param handler - Object containing keyboard event handlers.
+ * @param [deps] - Dependencies array for the effect.
+ * @example
+ * ```ts
+ * useSmoothKeyboardHandler(
+ *   {
+ *     onStart: (e) => {
+ *       "worklet";
+ *
+ *       // your handler for keyboard start
+ *     },
+ *   },
+ *   [],
+ * );
+ * ```
  */
 export declare const useSmoothKeyboardHandler: typeof useKeyboardHandler;

package/lib/typescript/components/KeyboardStickyView/index.d.ts

@@ -14,9 +14,22 @@ export type KeyboardStickyViewProps = {
          */
         opened?: number;
     };
-    /** Controls whether this `KeyboardStickyView` instance should take effect. Default is `true` */
+    /** Controls whether this `KeyboardStickyView` instance should take effect. Default is `true`. */
     enabled?: boolean;
 } & ViewProps;
+/**
+ * A View component that sticks to the keyboard and moves with it when it appears or disappears.
+ * The view can be configured with custom offsets for both closed and open keyboard states.
+ *
+ * @returns An animated View component that sticks to the keyboard.
+ * @see {@link https://kirillzyusko.github.io/react-native-keyboard-controller/docs/api/components/keyboard-sticky-view|Documentation} page for more details.
+ * @example
+ * ```tsx
+ * <KeyboardStickyView offset={{ closed: 0, opened: 20 }}>
+ *   <Button title="Submit" />
+ * </KeyboardStickyView>
+ * ```
+ */
 declare const KeyboardStickyView: React.ForwardRefExoticComponent<{
     /**
      * Specify additional offset to the view for given keyboard state.
@@ -31,7 +44,7 @@ declare const KeyboardStickyView: React.ForwardRefExoticComponent<{
          */
         opened?: number;
     };
-    /** Controls whether this `KeyboardStickyView` instance should take effect. Default is `true` */
+    /** Controls whether this `KeyboardStickyView` instance should take effect. Default is `true`. */
     enabled?: boolean;
 } & ViewProps & {
     children?: React.ReactNode | undefined;

package/lib/typescript/components/KeyboardToolbar/index.d.ts

@@ -46,11 +46,22 @@ export type KeyboardToolbarProps = Omit<ViewProps, "style" | "testID" | "childre
      * A value for container opacity in hexadecimal format (e.g. `ff`). Default value is `ff`.
      */
     opacity?: HEX;
+    /**
+     * A object containing `left`/`right` properties. Used to specify proper container padding in landscape mode.
+     */
     insets?: SafeAreaInsets;
 } & Pick<KeyboardStickyViewProps, "offset" | "enabled">;
 /**
- * `KeyboardToolbar` is a component that is shown above the keyboard with `Prev`/`Next` and
- * `Done` buttons.
+ * `KeyboardToolbar` is a component that is shown above the keyboard with `Prev`/`Next` buttons from left and
+ * `Done` button from the right (to dismiss the keyboard). Allows to add customizable content (yours UI elements) in the middle.
+ *
+ * @param props - Component props.
+ * @returns A component that is shown above the keyboard with `Prev`/`Next` and `Done` buttons.
+ * @see {@link https://kirillzyusko.github.io/react-native-keyboard-controller/docs/api/components/keyboard-toolbar|Documentation} page for more details.
+ * @example
+ * ```tsx
+ * <KeyboardToolbar doneText="Close" />
+ * ```
  */
 declare const KeyboardToolbar: React.FC<KeyboardToolbarProps>;
 export { colors as DefaultKeyboardToolbarTheme };

package/lib/typescript/context.d.ts

@@ -3,21 +3,53 @@ import type { FocusedInputHandler, FocusedInputLayoutChangedEvent, KeyboardHandl
 import type React from "react";
 import type { SharedValue } from "react-native-reanimated";
 export type AnimatedContext = {
+    /**
+     * A value between `0` and `1` indicating keyboard position, where `0` means keyboard is closed and `1` means keyboard is fully visible.
+     * Represented as `Animated.Value`.
+     */
     progress: Animated.Value;
+    /** Height of the keyboard. Represented as `Animated.Value`. */
     height: Animated.AnimatedMultiplication<number>;
 };
 export type ReanimatedContext = {
+    /**
+     * A value between `0` and `1` indicating keyboard position, where `0` means keyboard is closed and `1` means keyboard is fully visible.
+     * Represented as `SharedValue`.
+     */
     progress: SharedValue<number>;
+    /** Height of the keyboard. Represented as `SharedValue`. */
     height: SharedValue<number>;
 };
 export type KeyboardAnimationContext = {
+    /** Whether KeyboardController library is active or not. */
     enabled: boolean;
+    /** Object that stores animated values that reflect the keyboard’s current position and movement. */
     animated: AnimatedContext;
+    /** Object that stores reanimated values that reflect the keyboard’s current position and movement. */
     reanimated: ReanimatedContext;
+    /** Layout of the focused `TextInput` represented as `SharedValue`. */
     layout: SharedValue<FocusedInputLayoutChangedEvent | null>;
+    /** Method for setting workletized keyboard handlers. */
     setKeyboardHandlers: (handlers: KeyboardHandler) => () => void;
+    /** Method for setting workletized handlers for tracking focused input events. */
     setInputHandlers: (handlers: FocusedInputHandler) => () => void;
+    /** Method to enable/disable KeyboardController library. */
     setEnabled: React.Dispatch<React.SetStateAction<boolean>>;
 };
 export declare const KeyboardContext: React.Context<KeyboardAnimationContext>;
+/**
+ * A hook that returns a reference to {@link KeyboardAnimationContext} object.
+ *
+ * @returns Object {@link KeyboardAnimationContext|containing} keyboard-controller context.
+ * @example
+ * ```ts
+ *   const context = useKeyboardContext();
+ *
+ *   useLayoutEffect(() => {
+ *     const cleanup = context.setInputHandlers(handler);
+ *
+ *     return () => cleanup();
+ *   }, deps);
+ * ```
+ */
 export declare const useKeyboardContext: () => KeyboardAnimationContext;

package/lib/typescript/hooks/index.d.ts

@@ -1,18 +1,175 @@
 import type { AnimatedContext, ReanimatedContext } from "../context";
 import type { FocusedInputHandler, KeyboardHandler } from "../types";
 import type { DependencyList } from "react";
+/**
+ * Hook that sets the Android soft input mode to adjust resize on mount and
+ * restores default mode on unmount. This ensures the keyboard behavior is consistent
+ * on all Android versions.
+ *
+ * @see {@link https://kirillzyusko.github.io/react-native-keyboard-controller/docs/api/keyboard-controller#setinputmode-|Documentation} page for more details.
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   useResizeMode();
+ *   return <View />;
+ * }
+ * ```
+ */
 export declare const useResizeMode: () => void;
+/**
+ * Hook that provides animated (`height`/`progress`) values for tracking keyboard movement.
+ * Automatically sets the resize mode for Android.
+ *
+ * @returns Object {@link AnimatedContext|containing} animated values for keyboard movement.
+ * @see {@link https://kirillzyusko.github.io/react-native-keyboard-controller/docs/api/hooks/keyboard/use-keyboard-animation|Documentation} page for more details.
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { height, progress } = useKeyboardAnimation();
+ *   return <Animated.View style={{ transform: [{ translateY: height }] }} />;
+ * }
+ * ```
+ */
 export declare const useKeyboardAnimation: () => AnimatedContext;
+/**
+ * Hook that provides reanimated (`height`/`progress`) values for tracking keyboard movement.
+ * Automatically sets the resize mode for Android.
+ *
+ * @returns Object {@link ReanimatedContext|containing} reanimated values for keyboard movement.
+ * @see {@link https://kirillzyusko.github.io/react-native-keyboard-controller/docs/api/hooks/keyboard/use-reanimated-keyboard-animation|Documentation} page for more details.
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { height, progress } = useReanimatedKeyboardAnimation();
+ *   return <Reanimated.View style={{ transform: [{ translateY: height }] }} />;
+ * }
+ * ```
+ */
 export declare const useReanimatedKeyboardAnimation: () => ReanimatedContext;
+/**
+ * An alternative to {@link useKeyboardHandler} that doesn't set resize mode on mount. If your
+ * app already uses `adjustResize`, then you can use this hook instead of `useKeyboardHandler`.
+ *
+ * @param handler - Object containing keyboard event handlers.
+ * @param [deps] - Dependencies array for the effect.
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const height = useSharedValue(0);
+ *   const progress = useSharedValue(0);
+ *
+ *   useGenericKeyboardHandler({
+ *     onMove: (e) => {
+ *       "worklet";
+ *
+ *       height.value = e.height;
+ *       progress.value = e.progress;
+ *     },
+ *     onEnd: (e) => {
+ *       "worklet";
+ *
+ *       height.value = e.height;
+ *       progress.value = e.progress;
+ *     },
+ *   }, []);
+ *
+ *   return <Reanimated.View style={{ height: height }] }} />;
+ * }
+ * ```
+ */
 export declare function useGenericKeyboardHandler(handler: KeyboardHandler, deps?: DependencyList): void;
+/**
+ * Hook that gives an access to each aspect of keyboard movement with workletized `onStart`/`onMove`/`onInteractive`/`onEnd` handlers.
+ *
+ * @param handler - Object containing keyboard event handlers.
+ * @param [deps] - Dependencies array for the effect.
+ * @see {@link https://kirillzyusko.github.io/react-native-keyboard-controller/docs/api/hooks/keyboard/use-keyboard-handler|Documentation} page for more details.
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const height = useSharedValue(0);
+ *   const progress = useSharedValue(0);
+ *
+ *   useKeyboardHandler({
+ *     onMove: (e) => {
+ *       "worklet";
+ *
+ *       height.value = e.height;
+ *       progress.value = e.progress;
+ *     },
+ *     onEnd: (e) => {
+ *       "worklet";
+ *
+ *       height.value = e.height;
+ *       progress.value = e.progress;
+ *     },
+ *   }, []);
+ *
+ *   return <Reanimated.View style={{ height: height }] }} />;
+ * }
+ * ```
+ */
 export declare function useKeyboardHandler(handler: KeyboardHandler, deps?: DependencyList): void;
+/**
+ * Hook for controlling keyboard controller module.
+ * Allows to disable/enable it and check the actual state (whether it's enabled or not).
+ * When disabled it fallbacks to default android keyboard handling and stops tracking all
+ * the events that are exposed from this library.
+ *
+ * @property {Function} setEnabled - Function to enable/disable keyboard handling.
+ * @property {boolean} enabled - Current enabled state.
+ * @returns Object containing keyboard control functions and state.
+ * @see {@link https://kirillzyusko.github.io/react-native-keyboard-controller/docs/api/hooks/module/use-keyboard-controller|Documentation} page for more details.
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { setEnabled, enabled } = useKeyboardController();
+ *   return (
+ *     <Button
+ *       title={enabled ? 'Disable' : 'Enable'}
+ *       onPress={() => setEnabled(!enabled)}
+ *     />
+ *   );
+ * }
+ * ```
+ */
 export declare function useKeyboardController(): {
     setEnabled: import("react").Dispatch<import("react").SetStateAction<boolean>>;
     enabled: boolean;
 };
+/**
+ * Hook that provides access to the layout of the currently focused input.
+ *
+ * @returns Object containing reanimated values for focused input.
+ * @see {@link https://kirillzyusko.github.io/react-native-keyboard-controller/docs/api/hooks/input/use-reanimated-focused-input|Documentation} page for more details.
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { input } = useReanimatedFocusedInput();
+ *   return <Reanimated.View style={{ height: input.value?.layout.height }} />;
+ * }
+ * ```
+ */
 export declare function useReanimatedFocusedInput(): {
     input: import("react-native-reanimated").SharedValue<import("../types").FocusedInputLayoutChangedEvent | null>;
 };
+/**
+ * Hook for handling focused input events, such as changes of selection, text etc.
+ *
+ * @param handler - Object containing focused input event handlers.
+ * @param [deps] - Dependencies array for the effect.
+ * @see {@link https://kirillzyusko.github.io/react-native-keyboard-controller/docs/api/hooks/input/use-focused-input-handler|Documentation} page for more details.
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   useFocusedInputHandler({
+ *     onChangeText: (e) => console.log('Text changed:', e.text),
+ *     onSelectionChange: (e) => console.log('Selection changed:', e.selection)
+ *   });
+ *   return <View />;
+ * }
+ * ```
+ */
 export declare function useFocusedInputHandler(handler: FocusedInputHandler, deps?: DependencyList): void;
 export * from "./useWindowDimensions";
 export * from "./useKeyboardState";

package/lib/typescript/hooks/useKeyboardState/index.d.ts

@@ -1,2 +1,22 @@
 import type { KeyboardState } from "../../types";
+/**
+ * React Hook that represents the current keyboard state on iOS and Android.
+ * It tracks keyboard visibility, height, appearance, type and other properties.
+ * This hook subscribes to keyboard events and updates the state reactively.
+ *
+ * @returns Object {@link KeyboardState|containing} keyboard state information.
+ * @see {@link https://kirillzyusko.github.io/react-native-keyboard-controller/docs/api/hooks/keyboard/use-keyboard-state|Documentation} page for more details.
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { isVisible, height } = useKeyboardState();
+ *   return (
+ *     <View>
+ *       <Text>Keyboard is {isVisible ? 'visible' : 'hidden'}</Text>
+ *       <Text>Keyboard height: {height}</Text>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
 export declare const useKeyboardState: () => KeyboardState;

package/lib/typescript/internal.d.ts

@@ -2,6 +2,20 @@ import { Animated } from "react-native";
 import { findNodeHandle } from "./utils/findNodeHandle";
 type EventHandler = (event: never) => void;
 type ComponentOrHandle = Parameters<typeof findNodeHandle>[0];
+/**
+ * An internal hook that helps to register workletized event handlers.
+ *
+ * @param map - Map of event handlers and their names.
+ * @param viewTagRef - Ref to the view that produces events.
+ * @returns A function that registers supplied event handlers.
+ * @example
+ * ```ts
+ * const setKeyboardHandlers = useEventHandlerRegistration<KeyboardHandler>(
+ *     keyboardEventsMap,
+ *     viewTagRef,
+ * );
+ * ```
+ */
 export declare function useEventHandlerRegistration<H extends Partial<Record<string, EventHandler>>>(map: Map<keyof H, string>, viewTagRef: React.MutableRefObject<ComponentOrHandle>): (handler: H) => () => void;
 /**
  * TS variant of `useAnimatedValue` hook which is added in RN 0.71
@@ -10,7 +24,14 @@ export declare function useEventHandlerRegistration<H extends Partial<Record<str
  * and therefore consumes less memory. We can not use a variant from
  * RN, since this library supports earlier versions of RN.
  *
+ * @param initialValue - Initial value of the animated value (numeric).
+ * @param config - Additional {@link Animated.AnimatedConfig|configuration} for the animated value.
+ * @returns Properly memoized {@link Animated.Value|Animated} value.
  * @see https://github.com/facebook/react-native/commit/e22217fe8b9455e32695f88ca835e11442b0a937
+ * @example
+ * ```ts
+ * const progress = useAnimatedValue(0);
+ * ```
  */
 export declare function useAnimatedValue(initialValue: number, config?: Animated.AnimatedConfig): Animated.Value;
 export {};

package/lib/typescript/module.d.ts

@@ -1,2 +1,5 @@
 import type { KeyboardControllerModule } from "./types";
+/**
+ * KeyboardController module. Helps to perform imperative actions/checks with keyboard.
+ */
 export declare const KeyboardController: KeyboardControllerModule;

package/lib/typescript/{types.d.ts → types/hooks.d.ts}

@@ -1,37 +1,58 @@
-import type { PropsWithChildren } from "react";
-import type { EmitterSubscription, NativeSyntheticEvent, TextInputProps, ViewProps } from "react-native";
+import type { NativeSyntheticEvent, ViewProps } from "react-native";
 export type NativeEvent = {
+    /** A value between `0` and `1` indicating keyboard position, where `0` means keyboard is closed and `1` means keyboard is fully visible. */
     progress: number;
+    /** Height of the keyboard. */
     height: number;
+    /** Duration of the keyboard animation. */
     duration: number;
+    /** Tag of the focused `TextInput`. */
     target: number;
 };
 export type FocusedInputLayoutChangedEvent = {
+    /** Tag of the focused `TextInput`. */
     target: number;
+    /** Tag of the parent `ScrollView`. */
     parentScrollViewTarget: number;
     layout: {
+        /** X coordinate of the focused `TextInput`. */
         x: number;
+        /** Y coordinate of the focused `TextInput`. */
         y: number;
+        /** Width of the focused `TextInput`. */
         width: number;
+        /** Height of the focused `TextInput`. */
         height: number;
+        /** X coordinate of the focused `TextInput` relative to the screen. */
         absoluteX: number;
+        /** Y coordinate of the focused `TextInput` relative to the screen. */
         absoluteY: number;
     };
 };
 export type FocusedInputTextChangedEvent = {
+    /** Text that user typed in the focused `TextInput`. */
     text: string;
 };
 export type FocusedInputSelectionChangedEvent = {
+    /** Tag of the focused `TextInput`. */
     target: number;
     selection: {
+        /** Start of the selection. Represents top-left point of rectangle. */
         start: {
+            /** X coordinate of the selection start (relative to the `TextInput`). */
             x: number;
+            /** Y coordinate of the selection start (relative to the `TextInput`). */
             y: number;
+            /** The start of selection. */
             position: number;
         };
+        /** End of the selection. Represents bottom-right point of rectangle. */
         end: {
+            /** X coordinate of the selection end (relative to the `TextInput`). */
             x: number;
+            /** Y coordinate of the selection end (relative to the `TextInput`). */
             y: number;
+            /** The end of selection. */
             position: number;
         };
     };
@@ -57,82 +78,6 @@ export type KeyboardControllerProps = {
     preserveEdgeToEdge?: boolean;
     enabled?: boolean;
 } & ViewProps;
-export type KeyboardGestureAreaProps = {
-    interpolator?: "ios" | "linear";
-    /**
-     * Whether to allow to show a keyboard from dismissed state by swipe up.
-     * Default to `false`.
-     */
-    showOnSwipeUp?: boolean;
-    /**
-     * Whether to allow to control a keyboard by gestures. The strategy how
-     * it should be controlled is determined by `interpolator` property.
-     * Defaults to `true`.
-     */
-    enableSwipeToDismiss?: boolean;
-    /**
-     * Extra distance to the keyboard.
-     */
-    offset?: number;
-    /**
-     * A corresponding `nativeID` value from the corresponding `TextInput`.
-     */
-    textInputNativeID?: string;
-} & ViewProps;
-export type OverKeyboardViewProps = PropsWithChildren<{
-    visible: boolean;
-}>;
-export type Direction = "next" | "prev" | "current";
-export type DismissOptions = {
-    keepFocus: boolean;
-};
-export type KeyboardControllerModule = {
-    setDefaultMode: () => void;
-    setInputMode: (mode: number) => void;
-    dismiss: (options?: DismissOptions) => Promise<void>;
-    setFocusTo: (direction: Direction) => void;
-    isVisible: () => boolean;
-    state: () => KeyboardEventData;
-};
-export type KeyboardControllerNativeModule = {
-    setDefaultMode: () => void;
-    setInputMode: (mode: number) => void;
-    dismiss: (keepFocus: boolean) => void;
-    setFocusTo: (direction: Direction) => void;
-    addListener: (eventName: string) => void;
-    removeListeners: (count: number) => void;
-};
-export type KeyboardControllerEvents = "keyboardWillShow" | "keyboardDidShow" | "keyboardWillHide" | "keyboardDidHide";
-export type KeyboardEventData = {
-    height: number;
-    duration: number;
-    timestamp: number;
-    target: number;
-    type: NonNullable<TextInputProps["keyboardType"]>;
-    appearance: NonNullable<TextInputProps["keyboardAppearance"]>;
-};
-export type KeyboardState = {
-    isVisible: boolean;
-} & KeyboardEventData;
-export type KeyboardEventsModule = {
-    addListener: (name: KeyboardControllerEvents, cb: (e: KeyboardEventData) => void) => EmitterSubscription;
-};
-export type FocusedInputAvailableEvents = "focusDidSet";
-export type FocusedInputEventData = {
-    current: number;
-    count: number;
-};
-export type FocusedInputEventsModule = {
-    addListener: (name: FocusedInputAvailableEvents, cb: (e: FocusedInputEventData) => void) => EmitterSubscription;
-};
-export type WindowDimensionsAvailableEvents = "windowDidResize";
-export type WindowDimensionsEventData = {
-    width: number;
-    height: number;
-};
-export type WindowDimensionsEventsModule = {
-    addListener: (name: WindowDimensionsAvailableEvents, cb: (e: WindowDimensionsEventData) => void) => EmitterSubscription;
-};
 export type KeyboardHandlerHook<TContext, Event> = (handlers: {
     onKeyboardMoveStart?: (e: NativeEvent, context: TContext) => void;
     onKeyboardMove?: (e: NativeEvent, context: TContext) => void;
@@ -150,14 +95,63 @@ export type FocusedInputSelectionHandlerHook<TContext, Event> = (handlers: {
 }, dependencies?: unknown[]) => (e: NativeSyntheticEvent<Event>) => void;
 export type Handlers<T> = Record<string, T | undefined>;
 export type KeyboardHandler = Partial<{
+    /**
+     * A callback that gets invoked when keyboard starts its movement.
+     * The event contains DESTINATION values.
+     *
+     * @example
+     * ```ts
+     * onStart: (e) => {
+     *   "worklet";
+     *
+     *   const willKeyboardAppear = e.progress === 1;
+     * }
+     * ```
+     */
     onStart: (e: NativeEvent) => void;
+    /**
+     * A callback that gets involved every frame when keyboard changes its position.
+     *
+     * @example
+     * ```ts
+     * onMove: (e) => {
+     *   "worklet";
+     *
+     *   const keyboardHeight = e.height;
+     * }
+     */
     onMove: (e: NativeEvent) => void;
+    /**
+     * A callback that gets invoked when keyboard finished its movement.
+     *
+     * @example
+     * ```ts
+     * onEnd: (e) => {
+     *   "worklet";
+     *
+     *   const isKeyboardShown = e.progress === 1;
+     * }
+     * ```
+     */
     onEnd: (e: NativeEvent) => void;
+    /**
+     * A callback that gets invoked every frame when keyboard changes its position due to interactive dismissal.
+     *
+     * @example
+     * ```ts
+     * onInteractive: (e) => {
+     *   "worklet";
+     *
+     *   const keyboardHeight = e.height;
+     * }
+     */
     onInteractive: (e: NativeEvent) => void;
 }>;
 export type KeyboardHandlers = Handlers<KeyboardHandler>;
 export type FocusedInputHandler = Partial<{
+    /** A callback that gets invoked every time when the text changes in focused input. */
     onChangeText: (e: FocusedInputTextChangedEvent) => void;
+    /** A callback that gets invoked every time when the selection (cursor) coordinates change in focused input. */
     onSelectionChange: (e: FocusedInputSelectionChangedEvent) => void;
 }>;
 export type FocusedInputHandlers = Handlers<FocusedInputHandler>;

package/lib/typescript/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./hooks";
+export * from "./views";
+export * from "./module";
+export * from "./internal";