import { type AnyResolvedKeyframe, type MotionValue, type TransformOptions } from "motion-dom";
export type InputRange = number[];
/**
 * Branded wrapper for a getter that returns the **input range** (breakpoints) of a range→range transform.
 * In motion-vue this role is `MaybeRef<InputRange>`; in Svelte use `reactiveInputRange` so the second
 * argument position stays unambiguous (plain functions remain value transformers only).
 */
declare const ReactiveInputRangeBrand: unique symbol;
export type ReactiveInputRange = {
    readonly [ReactiveInputRangeBrand]: true;
    readonly read: () => InputRange;
};
/**
 * Mark a getter as a reactive **input range** for `useTransform` (range→range overload).
 *
 * @remarks
 * When breakpoints must update (layout, config, etc.), wrap them with `reactiveInputRange(() => [...])`.
 * Do not pass a bare function for this purpose — unmarked functions in the second position are always
 * interpreted as `SingleTransformer` / `MultiTransformer`.
 *
 * @param read - Getter returning a linear series of numbers (same rules as a static `InputRange`).
 * @returns Opaque value to pass as `inputRange` to `useTransform`.
 *
 * @public
 */
export declare function reactiveInputRange(read: () => InputRange): ReactiveInputRange;
type SingleTransformer<I, O> = (input: I) => O;
type MultiTransformer<I, O> = (input: I[]) => O;
/**
 * Create a `MotionValue` that transforms the output of another `MotionValue` by mapping it from one range of values into another.
 *
 * @remarks
 *
 * Given an input range of `[-200, -100, 100, 200]` and an output range of
 * `[0, 1, 1, 0]`, the returned `MotionValue` will:
 *
 * - When provided a value between `-200` and `-100`, will return a value between `0` and  `1`.
 * - When provided a value between `-100` and `100`, will return `1`.
 * - When provided a value between `100` and `200`, will return a value between `1` and  `0`
 *
 * The input range must be a linear series of numbers. The output range
 * can be any value type supported by Motion: numbers, colors, shadows, etc.
 *
 * Every value in the output range must be of the same type and in the same format.
 *
 * ```svelte
 * <script lang="ts">
 *   import { Motion, motionValue, useTransform } from "motion-sv";
 *
 *   const x = motionValue(0);
 *   const xRange = [-200, -100, 100, 200];
 *   const opacityRange = [0, 1, 1, 0];
 *   const opacity = useTransform(x, xRange, opacityRange);
 * </script>
 *
 * <Motion animate={{ x: 200 }} style={{ opacity, x }} />
 * ```
 *
 * @param inputValue - `MotionValue`
 * @param inputRange - A linear series of numbers (either all increasing or decreasing), or {@link reactiveInputRange} when the breakpoints should be reactive.
 * @param outputRange - A series of numbers, colors or strings. Must be the same length as `inputRange`.
 * @param options -
 *
 *  - clamp: boolean. Clamp values to within the given range. Defaults to `true`
 *  - ease: EasingFunction[]. Easing functions to use on the interpolations between each value in the input and output ranges. If provided as an array, the array must be one item shorter than the input and output ranges, as the easings apply to the transition between each.
 *
 * @returns `MotionValue`
 *
 * @public
 */
export declare function useTransform<I, O>(value: MotionValue<number>, inputRange: InputRange | ReactiveInputRange, outputRange: O[], options?: TransformOptions<O>): MotionValue<O>;
export declare function useTransform<I, O>(transformer: () => O): MotionValue<O>;
export declare function useTransform<I, O>(input: MotionValue<I>, transformer: SingleTransformer<I, O>): MotionValue<O>;
export declare function useTransform<I, O>(input: MotionValue<string>[] | MotionValue<number>[] | MotionValue<AnyResolvedKeyframe>[], transformer: MultiTransformer<I, O>): MotionValue<O>;
/**
 * Create multiple `MotionValue`s that transform the output of a single `MotionValue`.
 *
 * @remarks
 *
 * Allows transforming a single input into multiple outputs, useful for coordinated animations.
 *
 * ```svelte
 * <script lang="ts">
 *   import { Motion, useMotionValue, useTransform } from "motion-sv";
 *
 *   const x = useMotionValue(0);
 *   const { opacity, scale } = useTransform(x, [0, 100], {
 *     opacity: [0, 1],
 *     scale: [0.5, 1],
 *   });
 * </script>
 *
 * <Motion animate={{ x: 100 }} style={{ opacity, scale, x }} />
 * ```
 *
 * @param value - `MotionValue` to transform
 * @param inputRange - A linear series of numbers (either all increasing or decreasing), or {@link reactiveInputRange} when reactive.
 * @param outputRange - An object where each key maps to an output range array
 * @param options - Transform options (clamp, ease)
 *
 * @returns Object containing `MotionValue` for each output key
 *
 * @public
 */
export declare function useTransform<O>(value: MotionValue<number>, inputRange: InputRange | ReactiveInputRange, outputRange: {
    [K in keyof O]: O[K][];
}, options?: TransformOptions<O[keyof O]>): {
    [K in keyof O]: MotionValue<O[K]>;
};
export {};