@rootnative/inertia 0.0.7 → 0.0.9

package/dist/{chunk-REYL77RE.mjs → chunk-W7NTRSPD.mjs}

@@ -1,5 +1,5 @@
 import { isWorkletFunction } from 'react-native-worklets';
-import { withSequence, Easing, withDecay, withTiming, withSpring, withRepeat, withDelay } from 'react-native-reanimated';
+import { withDelay, withSequence, Easing, withDecay, withTiming, withSpring, withRepeat } from 'react-native-reanimated';
 
 // src/transitions/easing.ts
 
@@ -210,26 +210,33 @@ function bezier(x1, y1, x2, y2, source) {
   return Easing.bezier(x1, y1, x2, y2);
 }
 var DEFAULT_TIMING_DURATION2 = 250;
-function buildReleaseAnimation(transition, toValue) {
+function buildReleaseAnimation(transition, toValue, callback) {
   "worklet";
-  if (transition.type === "no-animation") return toValue;
+  if (transition.type === "no-animation") {
+    if (callback) callback(true, toValue);
+    return toValue;
+  }
   if (transition.type === "decay") {
     const cfg = { velocity: transition.velocity ?? 0 };
     if (transition.deceleration !== void 0) {
       cfg.deceleration = transition.deceleration;
     }
     if (transition.clamp !== void 0) cfg.clamp = transition.clamp;
-    return withDecay(cfg);
+    return withDecay(cfg, callback);
   }
   if (transition.type === "timing") {
     const e = transition.easing;
     const easingFn = e && typeof e === "object" && "factory" in e ? e.factory() : e ?? Easing.inOut(Easing.ease);
-    return withTiming(toValue, {
-      duration: transition.duration ?? DEFAULT_TIMING_DURATION2,
-      easing: easingFn
-    });
+    return withTiming(
+      toValue,
+      {
+        duration: transition.duration ?? DEFAULT_TIMING_DURATION2,
+        easing: easingFn
+      },
+      callback
+    );
   }
-  return withSpring(toValue, springToReanimated(transition));
+  return withSpring(toValue, springToReanimated(transition), callback);
 }
 
 // src/transitions/keys.ts
@@ -277,4 +284,4 @@ function stableStringify(v) {
   return "{" + keys.map((k) => JSON.stringify(k) + ":" + stableStringify(obj[k])).join(",") + "}";
 }
 
-export { DEFAULT_SPRING, buildReleaseAnimation, cubicBezier, ensureWorkletEasing, isTopLevelTransition, resolveAnimatableValue, resolveTransition, springToReanimated, stableSig, warnNonWorkletOnce, warnOnce };
+export { DEFAULT_SPRING, applyDelay, buildReleaseAnimation, cubicBezier, ensureWorkletEasing, isTopLevelTransition, resolveAnimatableValue, resolveTransition, springToReanimated, stableSig, warnNonWorkletOnce, warnOnce };

package/dist/{chunk-PM6CVGXJ.js → chunk-WNVHPMBI.js}

@@ -212,26 +212,33 @@ function bezier(x1, y1, x2, y2, source) {
   return reactNativeReanimated.Easing.bezier(x1, y1, x2, y2);
 }
 var DEFAULT_TIMING_DURATION2 = 250;
-function buildReleaseAnimation(transition, toValue) {
+function buildReleaseAnimation(transition, toValue, callback) {
   "worklet";
-  if (transition.type === "no-animation") return toValue;
+  if (transition.type === "no-animation") {
+    if (callback) callback(true, toValue);
+    return toValue;
+  }
   if (transition.type === "decay") {
     const cfg = { velocity: transition.velocity ?? 0 };
     if (transition.deceleration !== void 0) {
       cfg.deceleration = transition.deceleration;
     }
     if (transition.clamp !== void 0) cfg.clamp = transition.clamp;
-    return reactNativeReanimated.withDecay(cfg);
+    return reactNativeReanimated.withDecay(cfg, callback);
   }
   if (transition.type === "timing") {
     const e = transition.easing;
     const easingFn = e && typeof e === "object" && "factory" in e ? e.factory() : e ?? reactNativeReanimated.Easing.inOut(reactNativeReanimated.Easing.ease);
-    return reactNativeReanimated.withTiming(toValue, {
-      duration: transition.duration ?? DEFAULT_TIMING_DURATION2,
-      easing: easingFn
-    });
+    return reactNativeReanimated.withTiming(
+      toValue,
+      {
+        duration: transition.duration ?? DEFAULT_TIMING_DURATION2,
+        easing: easingFn
+      },
+      callback
+    );
   }
-  return reactNativeReanimated.withSpring(toValue, springToReanimated(transition));
+  return reactNativeReanimated.withSpring(toValue, springToReanimated(transition), callback);
 }
 
 // src/transitions/keys.ts
@@ -280,6 +287,7 @@ function stableStringify(v) {
 }
 
 exports.DEFAULT_SPRING = DEFAULT_SPRING;
+exports.applyDelay = applyDelay;
 exports.buildReleaseAnimation = buildReleaseAnimation;
 exports.cubicBezier = cubicBezier;
 exports.ensureWorkletEasing = ensureWorkletEasing;

package/dist/chunk-Z5USXWTE.js

@@ -0,0 +1,8 @@
+'use strict';
+
+var chunkE3ALFSH2_js = require('./chunk-E3ALFSH2.js');
+var reactNative = require('react-native');
+
+var MotionImage = chunkE3ALFSH2_js.createMotionComponent(reactNative.Image);
+
+exports.MotionImage = MotionImage;

package/dist/{chunk-QYR66E2G.js → chunk-ZBHQPVWE.js}

@@ -1,8 +1,8 @@
 'use strict';
 
-var chunk6V7MOBXO_js = require('./chunk-6V7MOBXO.js');
+var chunkE3ALFSH2_js = require('./chunk-E3ALFSH2.js');
 var reactNative = require('react-native');
 
-var MotionScrollView = chunk6V7MOBXO_js.createMotionComponent(reactNative.ScrollView);
+var MotionScrollView = chunkE3ALFSH2_js.createMotionComponent(reactNative.ScrollView);
 
 exports.MotionScrollView = MotionScrollView;

package/dist/gestureLayer/index.js

@@ -1,25 +1,25 @@
 'use strict';
 
-var chunk4NAMD62I_js = require('../chunk-4NAMD62I.js');
-var chunkOBRGJAST_js = require('../chunk-OBRGJAST.js');
-var chunkPM6CVGXJ_js = require('../chunk-PM6CVGXJ.js');
+var chunkMUT6BTZS_js = require('../chunk-MUT6BTZS.js');
+var chunk6AN5X3YE_js = require('../chunk-6AN5X3YE.js');
+var chunkWNVHPMBI_js = require('../chunk-WNVHPMBI.js');
 var react = require('react');
 var reactNativeReanimated = require('react-native-reanimated');
 
 function useGestureLayer(states, options = {}) {
   const { disabled: isDisabled = false, transition: transitionInput } = options;
-  const shouldReduceMotion = chunkOBRGJAST_js.useShouldReduceMotion();
-  const transition = chunkOBRGJAST_js.resolveNamedTransitionProp(
+  const shouldReduceMotion = chunk6AN5X3YE_js.useShouldReduceMotion();
+  const transition = chunk6AN5X3YE_js.resolveNamedTransitionProp(
     transitionInput,
-    chunkOBRGJAST_js.useNamedTransitions()
+    chunk6AN5X3YE_js.useNamedTransitions()
   );
-  const gesture = chunk4NAMD62I_js.useGesture(transition);
+  const gesture = chunkMUT6BTZS_js.useGesture(transition);
   const disabledProgress = reactNativeReanimated.useSharedValue(0);
-  const transitionSig = chunkPM6CVGXJ_js.stableSig(transition);
+  const transitionSig = chunkWNVHPMBI_js.stableSig(transition);
   react.useEffect(() => {
     const target = isDisabled ? 1 : 0;
     const cfg = shouldReduceMotion ? { type: "no-animation" } : disabledTransition(transition) ?? { type: "spring" };
-    disabledProgress.value = chunkPM6CVGXJ_js.resolveTransition(cfg, target);
+    disabledProgress.value = chunkWNVHPMBI_js.resolveTransition(cfg, target);
   }, [isDisabled, shouldReduceMotion, transitionSig, disabledProgress]);
   const meta = react.useMemo(() => {
     const layers = {
@@ -154,7 +154,7 @@ function useGestureLayer(states, options = {}) {
 }
 function disabledTransition(transition) {
   if (!transition) return void 0;
-  if (chunkPM6CVGXJ_js.isTopLevelTransition(transition)) return transition;
+  if (chunkWNVHPMBI_js.isTopLevelTransition(transition)) return transition;
   return void 0;
 }
 

package/dist/gestureLayer/index.mjs

@@ -1,6 +1,6 @@
-import { useGesture } from '../chunk-OW5XTGVN.mjs';
-import { useShouldReduceMotion, resolveNamedTransitionProp, useNamedTransitions } from '../chunk-Z3HCJ43H.mjs';
-import { stableSig, resolveTransition, isTopLevelTransition } from '../chunk-REYL77RE.mjs';
+import { useGesture } from '../chunk-L4JFECXU.mjs';
+import { useShouldReduceMotion, resolveNamedTransitionProp, useNamedTransitions } from '../chunk-MFAFB4K7.mjs';
+import { stableSig, resolveTransition, isTopLevelTransition } from '../chunk-W7NTRSPD.mjs';
 import { useEffect, useMemo } from 'react';
 import { useSharedValue, useAnimatedStyle, interpolateColor } from 'react-native-reanimated';
 

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import * as react from 'react';
 import { ComponentType, ReactNode } from 'react';
 import * as react_native from 'react-native';
-import { NativeSyntheticEvent, NativeScrollEvent } from 'react-native';
+import { TextStyle, ImageStyle, ViewStyle, NativeSyntheticEvent, NativeScrollEvent } from 'react-native';
 import { M as MotionComponent, V as VariantsMap, a as MotionProps, N as NamedTransitions, b as TransitionInput, T as TransitionConfig, A as AnimatableValue, E as EasingInput, S as SpringTransition, c as TransitionName, d as VariantController } from './types-DyJpG64F.mjs';
 export { e as AnimateStyle, f as AnimationCallbackInfo, B as BoxShadowInput, D as DecayTransition, g as EasingFunction, h as EasingFunctionFactory, i as GestureSubStates, j as NoAnimationTransition, P as PerPropertyTransition, R as RegisteredTransitions, k as RepeatConfig, l as SequenceStep, m as TimingTransition, n as Transition } from './types-DyJpG64F.mjs';
 import { SharedValue, useAnimatedStyle } from 'react-native-reanimated';
@@ -174,6 +174,64 @@ interface PresenceContextValue {
  */
 declare function usePresence(): PresenceContextValue | null;
 
+interface StaggerProps {
+    children?: ReactNode;
+    /**
+     * Milliseconds between consecutive children. Child `i` (in render order)
+     * receives a delay of `delay + i * interval`.
+     */
+    interval: number;
+    /**
+     * Base delay in milliseconds applied to every child before the interval,
+     * so the whole cascade can start late without pushing the spacing into
+     * each child. Defaults to `0`.
+     */
+    delay?: number;
+    /**
+     * Which end of the child list starts the cascade. `'first'` (default)
+     * staggers top-down in render order; `'last'` reverses it, so the final
+     * child animates first.
+     */
+    from?: 'first' | 'last';
+    /**
+     * Turn the stagger on or off in one place. When `false`, every child gets
+     * a delay of `0` — the single-switch escape hatch for "cascade in, but
+     * not back out": pass `enabled={revealed}` and the hide direction snaps
+     * together. Defaults to `true`.
+     */
+    enabled?: boolean;
+}
+/**
+ * Assign each child a stagger delay from its position, so a list entrance
+ * cascades without every child computing `index * ms` itself.
+ *
+ * The parent owns the timing: reordering, filtering, or reversing the list
+ * re-derives every delay from the new render order, and `enabled` turns the
+ * whole cascade off in one place. Each child slot gets its own provider, so
+ * a `Motion.*` primitive anywhere inside child `i`'s subtree inherits child
+ * `i`'s delay.
+ *
+ * The delay applies to the declarative animations of the `Motion.*`
+ * primitives underneath — the mount animation (`initial` → `animate`) and
+ * any later `animate` change. It deliberately does not delay `gesture`
+ * feedback, `<Presence>` exits, or reduced-motion snaps.
+ *
+ * `<Stagger>` renders no host view — only per-child context providers.
+ */
+declare function Stagger({ children, interval, delay, from, enabled, }: StaggerProps): react.JSX.Element;
+
+/**
+ * The stagger delay (in milliseconds) assigned to this element's child slot
+ * by the nearest `<Stagger>` ancestor. `0` when there is none, when the
+ * stagger is disabled, or for the first child of a zero-`delay` stagger.
+ *
+ * The `Motion.*` primitives consume this automatically. Custom animated
+ * components built on `resolveTransition` / `resolveAnimatableValue` call
+ * this hook and add the returned value to their animation delay so they
+ * participate in a `<Stagger>` the same way the built-in primitives do.
+ */
+declare function useStaggerDelay(): number;
+
 /**
  * UI-thread callback Reanimated invokes when an animation settles. Must be a
  * worklet — callers either author one with `'worklet'` or build one via
@@ -187,6 +245,13 @@ type AnimationCallback = (finished?: boolean, current?: number | string) => void
  * `withDecay` call.
  */
 type CallbackFactory = (phase: 'step' | 'animation', step: number | undefined) => AnimationCallback | undefined;
+/**
+ * Wrap an animation in `withDelay`. A missing / zero / negative delay is a
+ * pass-through. Exported for the factory's stagger wrap, which must delay a
+ * fully-resolved animation exactly once — merging the delay into the base
+ * config instead would re-apply it per sequence step.
+ */
+declare function applyDelay(animation: unknown, delay: number | undefined): unknown;
 /**
  * Build a Reanimated animation for a single property. Runs on the JS thread
  * once per change and produces a baked `withSpring` / `withTiming` /
@@ -293,8 +358,14 @@ declare function ensureWorkletEasing(easing: EasingInput | undefined): ((t: numb
  *
  * For decay transitions, `toValue` is ignored — decay decelerates from the
  * SV's current position via its own physics. Pass `0` if you don't have one.
+ *
+ * `callback`, when provided, fires once when the animation settles — the same
+ * `(finished) => void` shape Reanimated's `with*` factories accept. It runs on
+ * the UI thread, so bridge to JS with `runOnJS(...)` inside it. For
+ * `no-animation` the callback fires synchronously with `finished: true`, since
+ * a direct assignment has no settle point of its own.
  */
-declare function buildReleaseAnimation(transition: TransitionConfig, toValue: number): unknown;
+declare function buildReleaseAnimation(transition: TransitionConfig, toValue: number, callback?: AnimationCallback): unknown;
 
 /**
  * The one colour spelling Reanimated's animation drivers cannot accept.
@@ -618,6 +689,22 @@ type InterpolatedStyleMap = {
 } & {
     [K in ColorStyleKey]?: readonly string[];
 };
+/**
+ * The style shape a map of `K` produces. Transform keys collapse into the
+ * single `transform` array the worklet emits; every other key survives under
+ * its own name, typed from the RN style family it belongs to.
+ *
+ * This is what lets the return narrow to `ViewStyle` at a call site whose map
+ * holds only view keys. Reanimated's own `useAnimatedStyle` resolves to
+ * `DefaultStyle` (`ViewStyle | ImageStyle | TextStyle`), and that union is
+ * rejected inside a `StyleProp<ViewStyle>` array — `TextStyle` fails on
+ * `cursor` — so a consumer had to cast.
+ */
+type InterpolatedStyle<K extends keyof InterpolatedStyleMap> = {
+    [P in Exclude<K, TransformKey>]: P extends keyof TextStyle ? TextStyle[P] : P extends keyof ImageStyle ? ImageStyle[P] : P extends keyof ViewStyle ? ViewStyle[P] : never;
+} & (Extract<K, TransformKey> extends never ? unknown : {
+    transform: NonNullable<ViewStyle['transform']>;
+});
 interface UseInterpolatedStyleOptions {
     /**
      * Input range mapped onto every key's output range. Defaults to `[0, 1]`
@@ -675,7 +762,7 @@ interface UseInterpolatedStyleOptions {
  * hook stays fully declarative and hashable so unchanged maps produce zero
  * new UI-thread closures.
  */
-declare function useInterpolatedStyle(progress: SharedValue<number>, map: InterpolatedStyleMap, options?: UseInterpolatedStyleOptions): ReturnType<typeof useAnimatedStyle>;
+declare function useInterpolatedStyle<K extends keyof InterpolatedStyleMap>(progress: SharedValue<number>, map: Pick<InterpolatedStyleMap, K>, options?: UseInterpolatedStyleOptions): InterpolatedStyle<K>;
 
 /**
  * Create an animatable value owned by JS but readable from worklets.
@@ -905,4 +992,4 @@ declare function useShadow({ from, to, progress, }: UseShadowOptions): ReturnTyp
  */
 declare function useVariants<V extends Readonly<Record<string, object>>>(variants: V, initial?: keyof V & string): VariantController<keyof V & string>;
 
-export { AnimatableValue, type Animator, type BoxShadowLayer, type ColorCascadeLayer, type ColorStyleKey, EasingInput, type ExtrapolationMode, type InterpolatedStyleMap, Motion, MotionComponent, MotionConfig, type MotionConfigProps, type MotionConfigValue, MotionProps, NamedTransitions, type NumericStyleKey, Presence, type PresenceContextValue, type ReducedMotion, type ShadowConfig, SpringTransition, TRANSPARENT, type TransformKey, TransitionConfig, TransitionInput, TransitionName, type UseColorCascadeOptions, type UseColorTransitionOptions, type UseInterpolatedStyleOptions, type UseScrollResult, type UseShadowOptions, type UseTransformOptions, VariantController, VariantsMap, buildReleaseAnimation, createMotionComponent, cubicBezier, ensureWorkletEasing, resolveAnimatableValue, resolveNamedTransition, resolveTransition, useAnimation, useAnimator, useBooleanSpring, useColorCascade, useColorTransition, useInterpolatedStyle, useMotionConfig, useMotionValue, useNamedTransitions, usePresence, useScroll, useShadow, useShouldReduceMotion, useSpring, useTransform, useVariants };
+export { AnimatableValue, type AnimationCallback, type Animator, type BoxShadowLayer, type ColorCascadeLayer, type ColorStyleKey, EasingInput, type ExtrapolationMode, type InterpolatedStyle, type InterpolatedStyleMap, Motion, MotionComponent, MotionConfig, type MotionConfigProps, type MotionConfigValue, MotionProps, NamedTransitions, type NumericStyleKey, Presence, type PresenceContextValue, type ReducedMotion, type ShadowConfig, SpringTransition, Stagger, type StaggerProps, TRANSPARENT, type TransformKey, TransitionConfig, TransitionInput, TransitionName, type UseColorCascadeOptions, type UseColorTransitionOptions, type UseInterpolatedStyleOptions, type UseScrollResult, type UseShadowOptions, type UseTransformOptions, VariantController, VariantsMap, applyDelay, buildReleaseAnimation, createMotionComponent, cubicBezier, ensureWorkletEasing, resolveAnimatableValue, resolveNamedTransition, resolveTransition, useAnimation, useAnimator, useBooleanSpring, useColorCascade, useColorTransition, useInterpolatedStyle, useMotionConfig, useMotionValue, useNamedTransitions, usePresence, useScroll, useShadow, useShouldReduceMotion, useSpring, useStaggerDelay, useTransform, useVariants };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as react from 'react';
 import { ComponentType, ReactNode } from 'react';
 import * as react_native from 'react-native';
-import { NativeSyntheticEvent, NativeScrollEvent } from 'react-native';
+import { TextStyle, ImageStyle, ViewStyle, NativeSyntheticEvent, NativeScrollEvent } from 'react-native';
 import { M as MotionComponent, V as VariantsMap, a as MotionProps, N as NamedTransitions, b as TransitionInput, T as TransitionConfig, A as AnimatableValue, E as EasingInput, S as SpringTransition, c as TransitionName, d as VariantController } from './types-DyJpG64F.js';
 export { e as AnimateStyle, f as AnimationCallbackInfo, B as BoxShadowInput, D as DecayTransition, g as EasingFunction, h as EasingFunctionFactory, i as GestureSubStates, j as NoAnimationTransition, P as PerPropertyTransition, R as RegisteredTransitions, k as RepeatConfig, l as SequenceStep, m as TimingTransition, n as Transition } from './types-DyJpG64F.js';
 import { SharedValue, useAnimatedStyle } from 'react-native-reanimated';
@@ -174,6 +174,64 @@ interface PresenceContextValue {
  */
 declare function usePresence(): PresenceContextValue | null;
 
+interface StaggerProps {
+    children?: ReactNode;
+    /**
+     * Milliseconds between consecutive children. Child `i` (in render order)
+     * receives a delay of `delay + i * interval`.
+     */
+    interval: number;
+    /**
+     * Base delay in milliseconds applied to every child before the interval,
+     * so the whole cascade can start late without pushing the spacing into
+     * each child. Defaults to `0`.
+     */
+    delay?: number;
+    /**
+     * Which end of the child list starts the cascade. `'first'` (default)
+     * staggers top-down in render order; `'last'` reverses it, so the final
+     * child animates first.
+     */
+    from?: 'first' | 'last';
+    /**
+     * Turn the stagger on or off in one place. When `false`, every child gets
+     * a delay of `0` — the single-switch escape hatch for "cascade in, but
+     * not back out": pass `enabled={revealed}` and the hide direction snaps
+     * together. Defaults to `true`.
+     */
+    enabled?: boolean;
+}
+/**
+ * Assign each child a stagger delay from its position, so a list entrance
+ * cascades without every child computing `index * ms` itself.
+ *
+ * The parent owns the timing: reordering, filtering, or reversing the list
+ * re-derives every delay from the new render order, and `enabled` turns the
+ * whole cascade off in one place. Each child slot gets its own provider, so
+ * a `Motion.*` primitive anywhere inside child `i`'s subtree inherits child
+ * `i`'s delay.
+ *
+ * The delay applies to the declarative animations of the `Motion.*`
+ * primitives underneath — the mount animation (`initial` → `animate`) and
+ * any later `animate` change. It deliberately does not delay `gesture`
+ * feedback, `<Presence>` exits, or reduced-motion snaps.
+ *
+ * `<Stagger>` renders no host view — only per-child context providers.
+ */
+declare function Stagger({ children, interval, delay, from, enabled, }: StaggerProps): react.JSX.Element;
+
+/**
+ * The stagger delay (in milliseconds) assigned to this element's child slot
+ * by the nearest `<Stagger>` ancestor. `0` when there is none, when the
+ * stagger is disabled, or for the first child of a zero-`delay` stagger.
+ *
+ * The `Motion.*` primitives consume this automatically. Custom animated
+ * components built on `resolveTransition` / `resolveAnimatableValue` call
+ * this hook and add the returned value to their animation delay so they
+ * participate in a `<Stagger>` the same way the built-in primitives do.
+ */
+declare function useStaggerDelay(): number;
+
 /**
  * UI-thread callback Reanimated invokes when an animation settles. Must be a
  * worklet — callers either author one with `'worklet'` or build one via
@@ -187,6 +245,13 @@ type AnimationCallback = (finished?: boolean, current?: number | string) => void
  * `withDecay` call.
  */
 type CallbackFactory = (phase: 'step' | 'animation', step: number | undefined) => AnimationCallback | undefined;
+/**
+ * Wrap an animation in `withDelay`. A missing / zero / negative delay is a
+ * pass-through. Exported for the factory's stagger wrap, which must delay a
+ * fully-resolved animation exactly once — merging the delay into the base
+ * config instead would re-apply it per sequence step.
+ */
+declare function applyDelay(animation: unknown, delay: number | undefined): unknown;
 /**
  * Build a Reanimated animation for a single property. Runs on the JS thread
  * once per change and produces a baked `withSpring` / `withTiming` /
@@ -293,8 +358,14 @@ declare function ensureWorkletEasing(easing: EasingInput | undefined): ((t: numb
  *
  * For decay transitions, `toValue` is ignored — decay decelerates from the
  * SV's current position via its own physics. Pass `0` if you don't have one.
+ *
+ * `callback`, when provided, fires once when the animation settles — the same
+ * `(finished) => void` shape Reanimated's `with*` factories accept. It runs on
+ * the UI thread, so bridge to JS with `runOnJS(...)` inside it. For
+ * `no-animation` the callback fires synchronously with `finished: true`, since
+ * a direct assignment has no settle point of its own.
  */
-declare function buildReleaseAnimation(transition: TransitionConfig, toValue: number): unknown;
+declare function buildReleaseAnimation(transition: TransitionConfig, toValue: number, callback?: AnimationCallback): unknown;
 
 /**
  * The one colour spelling Reanimated's animation drivers cannot accept.
@@ -618,6 +689,22 @@ type InterpolatedStyleMap = {
 } & {
     [K in ColorStyleKey]?: readonly string[];
 };
+/**
+ * The style shape a map of `K` produces. Transform keys collapse into the
+ * single `transform` array the worklet emits; every other key survives under
+ * its own name, typed from the RN style family it belongs to.
+ *
+ * This is what lets the return narrow to `ViewStyle` at a call site whose map
+ * holds only view keys. Reanimated's own `useAnimatedStyle` resolves to
+ * `DefaultStyle` (`ViewStyle | ImageStyle | TextStyle`), and that union is
+ * rejected inside a `StyleProp<ViewStyle>` array — `TextStyle` fails on
+ * `cursor` — so a consumer had to cast.
+ */
+type InterpolatedStyle<K extends keyof InterpolatedStyleMap> = {
+    [P in Exclude<K, TransformKey>]: P extends keyof TextStyle ? TextStyle[P] : P extends keyof ImageStyle ? ImageStyle[P] : P extends keyof ViewStyle ? ViewStyle[P] : never;
+} & (Extract<K, TransformKey> extends never ? unknown : {
+    transform: NonNullable<ViewStyle['transform']>;
+});
 interface UseInterpolatedStyleOptions {
     /**
      * Input range mapped onto every key's output range. Defaults to `[0, 1]`
@@ -675,7 +762,7 @@ interface UseInterpolatedStyleOptions {
  * hook stays fully declarative and hashable so unchanged maps produce zero
  * new UI-thread closures.
  */
-declare function useInterpolatedStyle(progress: SharedValue<number>, map: InterpolatedStyleMap, options?: UseInterpolatedStyleOptions): ReturnType<typeof useAnimatedStyle>;
+declare function useInterpolatedStyle<K extends keyof InterpolatedStyleMap>(progress: SharedValue<number>, map: Pick<InterpolatedStyleMap, K>, options?: UseInterpolatedStyleOptions): InterpolatedStyle<K>;
 
 /**
  * Create an animatable value owned by JS but readable from worklets.
@@ -905,4 +992,4 @@ declare function useShadow({ from, to, progress, }: UseShadowOptions): ReturnTyp
  */
 declare function useVariants<V extends Readonly<Record<string, object>>>(variants: V, initial?: keyof V & string): VariantController<keyof V & string>;
 
-export { AnimatableValue, type Animator, type BoxShadowLayer, type ColorCascadeLayer, type ColorStyleKey, EasingInput, type ExtrapolationMode, type InterpolatedStyleMap, Motion, MotionComponent, MotionConfig, type MotionConfigProps, type MotionConfigValue, MotionProps, NamedTransitions, type NumericStyleKey, Presence, type PresenceContextValue, type ReducedMotion, type ShadowConfig, SpringTransition, TRANSPARENT, type TransformKey, TransitionConfig, TransitionInput, TransitionName, type UseColorCascadeOptions, type UseColorTransitionOptions, type UseInterpolatedStyleOptions, type UseScrollResult, type UseShadowOptions, type UseTransformOptions, VariantController, VariantsMap, buildReleaseAnimation, createMotionComponent, cubicBezier, ensureWorkletEasing, resolveAnimatableValue, resolveNamedTransition, resolveTransition, useAnimation, useAnimator, useBooleanSpring, useColorCascade, useColorTransition, useInterpolatedStyle, useMotionConfig, useMotionValue, useNamedTransitions, usePresence, useScroll, useShadow, useShouldReduceMotion, useSpring, useTransform, useVariants };
+export { AnimatableValue, type AnimationCallback, type Animator, type BoxShadowLayer, type ColorCascadeLayer, type ColorStyleKey, EasingInput, type ExtrapolationMode, type InterpolatedStyle, type InterpolatedStyleMap, Motion, MotionComponent, MotionConfig, type MotionConfigProps, type MotionConfigValue, MotionProps, NamedTransitions, type NumericStyleKey, Presence, type PresenceContextValue, type ReducedMotion, type ShadowConfig, SpringTransition, Stagger, type StaggerProps, TRANSPARENT, type TransformKey, TransitionConfig, TransitionInput, TransitionName, type UseColorCascadeOptions, type UseColorTransitionOptions, type UseInterpolatedStyleOptions, type UseScrollResult, type UseShadowOptions, type UseTransformOptions, VariantController, VariantsMap, applyDelay, buildReleaseAnimation, createMotionComponent, cubicBezier, ensureWorkletEasing, resolveAnimatableValue, resolveNamedTransition, resolveTransition, useAnimation, useAnimator, useBooleanSpring, useColorCascade, useColorTransition, useInterpolatedStyle, useMotionConfig, useMotionValue, useNamedTransitions, usePresence, useScroll, useShadow, useShouldReduceMotion, useSpring, useStaggerDelay, useTransform, useVariants };