@symbiote-native/engine 0.1.0

package/build/animated/interpolation.js

@@ -0,0 +1,199 @@
+// Interpolation, ported from React Native's AnimatedInterpolation.js (the pure
+// `interpolate` math plus the string/color output-range branch). Maps an input
+// range to an output range through an easing function with configurable
+// extrapolation. A numeric output range stays number -> number; a string output
+// range (values-with-units like '0deg' or colors like '#000') is interpolated
+// per numeric token and reassembled. See createStringInterpolation below.
+import { normalizeColor } from './color';
+import { Easing } from './easing';
+function interpolateSegment(input, inputMin, inputMax, outputMin, outputMax, easing, extrapolateLeft, extrapolateRight) {
+    let result = input;
+    // Extrapolate below the range.
+    if (result < inputMin) {
+        if (extrapolateLeft === 'identity')
+            return result;
+        if (extrapolateLeft === 'clamp')
+            result = inputMin;
+        // 'extend' falls through (no-op).
+    }
+    // Extrapolate above the range.
+    if (result > inputMax) {
+        if (extrapolateRight === 'identity')
+            return result;
+        if (extrapolateRight === 'clamp')
+            result = inputMax;
+        // 'extend' falls through (no-op).
+    }
+    if (outputMin === outputMax)
+        return outputMin;
+    if (inputMin === inputMax) {
+        return input <= inputMin ? outputMin : outputMax;
+    }
+    // Normalize into the input segment.
+    if (inputMin === -Infinity) {
+        result = -result;
+    }
+    else if (inputMax === Infinity) {
+        result = result - inputMin;
+    }
+    else {
+        result = (result - inputMin) / (inputMax - inputMin);
+    }
+    result = easing(result);
+    // Project onto the output segment.
+    if (outputMin === -Infinity) {
+        result = -result;
+    }
+    else if (outputMax === Infinity) {
+        result = result + outputMin;
+    }
+    else {
+        result = result * (outputMax - outputMin) + outputMin;
+    }
+    return result;
+}
+function findRange(input, inputRange) {
+    let i = 1;
+    for (; i < inputRange.length - 1; ++i) {
+        if (inputRange[i] >= input)
+            break;
+    }
+    return i - 1;
+}
+function checkValidInputRange(arr) {
+    if (arr.length < 2)
+        throw new Error('inputRange must have at least 2 elements');
+    for (let i = 1; i < arr.length; ++i) {
+        if (!(arr[i] >= arr[i - 1])) {
+            throw new Error(`inputRange must be monotonically non-decreasing ${String(arr)}`);
+        }
+    }
+}
+function checkInfiniteRange(name, arr) {
+    if (arr.length < 2)
+        throw new Error(`${name} must have at least 2 elements`);
+    if (arr.length === 2 && arr[0] === -Infinity && arr[1] === Infinity) {
+        throw new Error(`${name} cannot be ]-infinity;+infinity[ ${String(arr)}`);
+    }
+}
+export function checkValidRanges(inputRange, outputRange) {
+    checkInfiniteRange('outputRange', outputRange);
+    checkInfiniteRange('inputRange', inputRange);
+    checkValidInputRange(inputRange);
+    if (inputRange.length !== outputRange.length) {
+        throw new Error(`inputRange (${inputRange.length}) and outputRange (${outputRange.length}) must have the same length`);
+    }
+}
+export function createNumericInterpolation(config) {
+    const { inputRange, outputRange } = config;
+    const easing = config.easing ?? Easing.linear;
+    const extrapolateLeft = config.extrapolateLeft ?? config.extrapolate ?? 'extend';
+    const extrapolateRight = config.extrapolateRight ?? config.extrapolate ?? 'extend';
+    return input => {
+        const range = findRange(input, inputRange);
+        return interpolateSegment(input, inputRange[range], inputRange[range + 1], outputRange[range], outputRange[range + 1], easing, extrapolateLeft, extrapolateRight);
+    };
+}
+// One numeric token: a signed int/float with optional fraction and exponent.
+// Sweeps a string for these so the surrounding non-numeric text (units, commas,
+// 'rgba(' ... ')') survives as the template. Ported from RN
+// AnimatedInterpolation.js:183.
+const numericComponentRegex = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g;
+// Split one output string into numeric components plus surrounding template.
+// A parseable color collapses to four channels (r,g,b 0-255, a 0-1) via the
+// shared color.ts RGBA decoder; any other string keeps its non-numeric text so
+// it can be rebuilt around the interpolated numbers. Ported from RN
+// AnimatedInterpolation.js:186 (mapStringToNumericComponents), with RN's packed-
+// int decode replaced by color.ts's RgbaValue (DRY: one RGBA parser).
+function mapStringToNumericComponents(input) {
+    const color = normalizeColor(input);
+    if (color !== undefined) {
+        return { isColor: true, components: [color.r, color.g, color.b, color.a] };
+    }
+    const components = [];
+    let lastMatchEnd = 0;
+    let match;
+    numericComponentRegex.lastIndex = 0;
+    while ((match = numericComponentRegex.exec(input)) !== null) {
+        if (match.index > lastMatchEnd) {
+            components.push(input.substring(lastMatchEnd, match.index));
+        }
+        components.push(Number.parseFloat(match[0]));
+        lastMatchEnd = match.index + match[0].length;
+    }
+    if (components.length === 0) {
+        throw new Error('outputRange must contain color or value with numeric component');
+    }
+    if (lastMatchEnd < input.length) {
+        components.push(input.substring(lastMatchEnd));
+    }
+    return { isColor: false, components };
+}
+// Interpolate a string output range. Each output string is decomposed into its
+// numeric tokens (and, for non-colors, the literal template between them); one
+// numeric interpolation is built per token position; at evaluation time the
+// tokens are interpolated and recombined into a string of the original shape:
+//
+//   '0deg' -> '360deg'              value-with-units  -> '180deg' at 0.5
+//   '#000000' -> '#ffffff'          color             -> 'rgba(128, 128, 128, 1)'
+//
+// Ported from RN AnimatedInterpolation.js:234 (createStringInterpolation).
+function createStringInterpolation(config, outputRange) {
+    if (outputRange.length < 2)
+        throw new Error('Bad output range');
+    const decomposed = outputRange.map(mapStringToNumericComponents);
+    const isColor = decomposed[0].isColor;
+    if (!decomposed.every(output => output.isColor === isColor)) {
+        throw new Error('All elements of output range should either be a color or a string with numeric components');
+    }
+    const firstLength = decomposed[0].components.length;
+    if (!decomposed.every(output => output.components.length === firstLength)) {
+        throw new Error('All elements of output range should have the same number of components');
+    }
+    // Per token position, the numeric values across all output strings, a number
+    // output range the scalar path can interpolate. Colors are already all-numeric;
+    // templates keep only the numeric tokens (the literal text is rejoined later).
+    const numericComponents = decomposed.map(output => output.isColor
+        ? output.components
+        : output.components.filter((c) => typeof c === 'number'));
+    const interpolations = numericComponents[0].map((_, tokenIndex) => createNumericInterpolation({
+        inputRange: config.inputRange,
+        outputRange: numericComponents.map(components => components[tokenIndex]),
+        easing: config.easing,
+        extrapolate: config.extrapolate,
+        extrapolateLeft: config.extrapolateLeft,
+        extrapolateRight: config.extrapolateRight,
+    }));
+    if (!isColor) {
+        // Walk the first output's template, dropping each interpolated number into
+        // the slot its numeric token occupied and copying the literal text through.
+        const template = decomposed[0].components;
+        return input => {
+            const values = interpolations.map(interpolation => interpolation(input));
+            let i = 0;
+            return template.map(c => (typeof c === 'number' ? values[i++] : c)).join('');
+        };
+    }
+    // Colors: r,g,b must be integers, so round them; alpha stays continuous but is
+    // rounded to 3 decimals to match RN's output. Matches RN
+    // AnimatedInterpolation.js:288-296.
+    return input => {
+        const channels = interpolations.map((interpolation, i) => {
+            const value = interpolation(input);
+            return i < 3 ? Math.round(value) : Math.round(value * 1000) / 1000;
+        });
+        return `rgba(${channels[0]}, ${channels[1]}, ${channels[2]}, ${channels[3]})`;
+    };
+}
+function isStringOutputRange(outputRange) {
+    return typeof outputRange[0] === 'string';
+}
+// Dispatch on the output range's element type: a string range (units or colors)
+// goes through createStringInterpolation, a numeric range through the scalar
+// path. Mirrors RN AnimatedInterpolation.js:373 (_getInterpolation).
+export function createInterpolation(config) {
+    if (isStringOutputRange(config.outputRange)) {
+        return createStringInterpolation(config, config.outputRange);
+    }
+    return createNumericInterpolation({ ...config, outputRange: config.outputRange });
+}

package/build/animated/mock.d.ts

@@ -0,0 +1,56 @@
+import { AnimatedValue } from './value';
+import { AnimatedValueXY } from './value-xy';
+import { AnimatedColor } from './color';
+import { add, subtract, multiply, divide, modulo, diffClamp } from './operators';
+import { event, forkEvent, unforkEvent } from './event';
+import type { ICompositeAnimation, ITimingConfig, ISpringConfig, IDecayConfig, IParallelConfig } from './animations/composition';
+declare function spring(value: AnimatedValue, config: ISpringConfig): ICompositeAnimation;
+declare function timing(value: AnimatedValue, config: ITimingConfig): ICompositeAnimation;
+declare function decay(_value: AnimatedValue, _config: IDecayConfig): ICompositeAnimation;
+declare function sequence(animations: ICompositeAnimation[]): ICompositeAnimation;
+declare function parallel(animations: ICompositeAnimation[], _config?: IParallelConfig): ICompositeAnimation;
+declare function delay(_time: number): ICompositeAnimation;
+declare function stagger(_time: number, animations: ICompositeAnimation[]): ICompositeAnimation;
+declare function loop(_animation: ICompositeAnimation): ICompositeAnimation;
+export declare const AnimatedMock: {
+    Value: typeof AnimatedValue;
+    ValueXY: typeof AnimatedValueXY;
+    Color: typeof AnimatedColor;
+    Easing: {
+        step0(n: number): number;
+        step1(n: number): number;
+        linear(t: number): number;
+        ease(t: number): number;
+        quad(t: number): number;
+        cubic(t: number): number;
+        poly(n: number): import("./easing").IEasingFunction;
+        sin(t: number): number;
+        circle(t: number): number;
+        exp(t: number): number;
+        elastic(bounciness?: number): import("./easing").IEasingFunction;
+        back(s?: number): import("./easing").IEasingFunction;
+        bounce(t: number): number;
+        bezier(x1: number, y1: number, x2: number, y2: number): import("./easing").IEasingFunction;
+        in(easing: import("./easing").IEasingFunction): import("./easing").IEasingFunction;
+        out(easing: import("./easing").IEasingFunction): import("./easing").IEasingFunction;
+        inOut(easing: import("./easing").IEasingFunction): import("./easing").IEasingFunction;
+    };
+    timing: typeof timing;
+    spring: typeof spring;
+    decay: typeof decay;
+    parallel: typeof parallel;
+    sequence: typeof sequence;
+    stagger: typeof stagger;
+    loop: typeof loop;
+    delay: typeof delay;
+    add: typeof add;
+    subtract: typeof subtract;
+    multiply: typeof multiply;
+    divide: typeof divide;
+    modulo: typeof modulo;
+    diffClamp: typeof diffClamp;
+    event: typeof event;
+    forkEvent: typeof forkEvent;
+    unforkEvent: typeof unforkEvent;
+};
+export {};

package/build/animated/mock.js

@@ -0,0 +1,127 @@
+// AnimatedMock: ported from RN's AnimatedMock.js. When the host reports
+// Platform.isDisableAnimations (reduced-motion accessibility setting, or a test
+// environment), RN swaps the whole Animated namespace for this mock: the surface
+// is identical but every animation jumps straight to its final value and fires the
+// end callback synchronously, with no frames. Snapshot tests and reduced-motion
+// users get the resting state without flake. The value graph, operators, easing,
+// events and createAnimatedComponent are reused verbatim from the live engine.
+// Only the driver factories (timing/spring/decay) and compositions are mocked.
+import { AnimatedValue } from './value';
+import { AnimatedValueXY } from './value-xy';
+import { AnimatedColor } from './color';
+import { AnimatedNode } from './graph';
+import { Easing } from './easing';
+import { add, subtract, multiply, divide, modulo, diffClamp } from './operators';
+import { event, forkEvent, unforkEvent } from './event';
+import { dlog } from '../debug';
+// Prevent a callback invocation from recursively triggering another callback,
+// which may trigger another animation (RN's AnimatedMock.js:36-60).
+let inAnimationCallback = false;
+function mockAnimationStart(start) {
+    return callback => {
+        const guardedCallback = callback === undefined
+            ? callback
+            : (result) => {
+                if (inAnimationCallback) {
+                    dlog('Ignoring recursive animation callback when running mock animations');
+                    return;
+                }
+                inAnimationCallback = true;
+                try {
+                    callback(result);
+                }
+                finally {
+                    inAnimationCallback = false;
+                }
+            };
+        start(guardedCallback);
+    };
+}
+const emptyAnimation = {
+    start: () => { },
+    stop: () => { },
+    reset: () => { },
+};
+function mockCompositeAnimation(animations) {
+    return {
+        ...emptyAnimation,
+        start: mockAnimationStart(callback => {
+            animations.forEach(animation => animation.start());
+            callback?.({ finished: true });
+        }),
+    };
+}
+// `toValue` is widened to `number | AnimatedNode` at the composition layer; the
+// mock needs a concrete number to land on, so resolve a node target to its current
+// value (RN reaches the same number through `anyValue`).
+function resolveToValue(toValue) {
+    if (toValue instanceof AnimatedNode) {
+        const current = toValue.__getValue();
+        return typeof current === 'number' ? current : 0;
+    }
+    return toValue;
+}
+function spring(value, config) {
+    return {
+        ...emptyAnimation,
+        start: mockAnimationStart(callback => {
+            value.setValue(resolveToValue(config.toValue));
+            callback?.({ finished: true });
+        }),
+    };
+}
+function timing(value, config) {
+    return {
+        ...emptyAnimation,
+        start: mockAnimationStart(callback => {
+            value.setValue(resolveToValue(config.toValue));
+            callback?.({ finished: true });
+        }),
+    };
+}
+// Decay has no toValue to land on, so RN returns the empty animation (AnimatedMock.js:121).
+function decay(_value, _config) {
+    return emptyAnimation;
+}
+function sequence(animations) {
+    return mockCompositeAnimation(animations);
+}
+function parallel(animations, _config) {
+    return mockCompositeAnimation(animations);
+}
+function delay(_time) {
+    return emptyAnimation;
+}
+function stagger(_time, animations) {
+    return mockCompositeAnimation(animations);
+}
+function loop(_animation) {
+    return emptyAnimation;
+}
+// The mocked namespace surface. The animation factories above resolve immediately;
+// everything else (value nodes, operators, easing, events) is the real engine. The
+// animated components are spread in by the caller (animated/index.ts) so this file
+// stays free of the createAnimatedComponent / TDZ-sensitive container wrapping.
+export const AnimatedMock = {
+    Value: AnimatedValue,
+    ValueXY: AnimatedValueXY,
+    Color: AnimatedColor,
+    Easing,
+    timing,
+    spring,
+    decay,
+    parallel,
+    sequence,
+    stagger,
+    loop,
+    delay,
+    add,
+    subtract,
+    multiply,
+    divide,
+    modulo,
+    diffClamp,
+    event,
+    forkEvent,
+    unforkEvent,
+};

package/build/animated/native/native-animated.d.ts

@@ -0,0 +1,43 @@
+export type IPlatformConfig = Record<string, unknown>;
+export interface INativeNodeConfig {
+    readonly type: string;
+    readonly [key: string]: unknown;
+}
+export interface INativeAnimationConfig {
+    readonly type: string;
+    readonly [key: string]: unknown;
+}
+export interface INativeEventMapping {
+    readonly nativeEventPath: readonly string[];
+    readonly animatedValueTag: number;
+}
+export interface INativeEndResult {
+    finished: boolean;
+    value?: number;
+    offset?: number;
+}
+export type INativeEndCallback = (result: INativeEndResult) => void;
+export declare function isNativeAnimatedAvailable(): boolean;
+export declare function generateNativeNodeTag(): number;
+export declare function generateNativeAnimationId(): number;
+export declare const nativeAnimated: {
+    createAnimatedNode(tag: number, config: INativeNodeConfig): void;
+    connectAnimatedNodes(parentTag: number, childTag: number): void;
+    disconnectAnimatedNodes(parentTag: number, childTag: number): void;
+    connectAnimatedNodeToView(nodeTag: number, viewTag: number): void;
+    disconnectAnimatedNodeFromView(nodeTag: number, viewTag: number): void;
+    restoreDefaultValues(nodeTag: number): void;
+    dropAnimatedNode(tag: number): void;
+    startAnimatingNode(animationId: number, nodeTag: number, config: INativeAnimationConfig, endCallback: INativeEndCallback): void;
+    stopAnimation(animationId: number): void;
+    setAnimatedNodeValue(nodeTag: number, value: number): void;
+    setAnimatedNodeOffset(nodeTag: number, offset: number): void;
+    flattenAnimatedNodeOffset(nodeTag: number): void;
+    extractAnimatedNodeOffset(nodeTag: number): void;
+    startListeningToAnimatedNodeValue(tag: number): void;
+    stopListeningToAnimatedNodeValue(tag: number): void;
+    startListeningToValue(tag: number, callback: (value: number) => void): void;
+    stopListeningToValue(tag: number): void;
+    addAnimatedEventToView(viewTag: number, eventName: string, mapping: INativeEventMapping): void;
+    removeAnimatedEventFromView(viewTag: number, eventName: string, animatedNodeTag: number): void;
+};

package/build/animated/native/native-animated.js

@@ -0,0 +1,146 @@
+// The native-driver bridge (ADR 0017). When an animation runs with
+// useNativeDriver:true, the whole value graph is mirrored into native "animated
+// nodes" and the curve is handed to the stock NativeAnimated TurboModule, which
+// then mutates the bound shadow node every frame with ZERO JS per frame.
+//
+// We consume the module that ships in stock react-native, no native fork. On
+// iOS bridgeless it registers as `NativeAnimatedTurboModule`; we fall back to the
+// legacy `NativeAnimatedModule` name. Resolution goes through the same JSI seam as
+// every other native module (getNativeModule), consistent with ADR 0012. The
+// module is resolved lazily on first use, so importing this file headless (no
+// native host) is inert until a native-driven animation actually starts.
+import { dlog } from '../../debug';
+import { getNativeModule } from '../../native-modules';
+import { NativeEventEmitter } from '../../native-events';
+// iOS bridgeless registers the Turbo variant; the legacy name is the fallback.
+const TURBO_MODULE_NAME = 'NativeAnimatedTurboModule';
+const LEGACY_MODULE_NAME = 'NativeAnimatedModule';
+let resolved = null;
+function module() {
+    if (resolved !== null)
+        return resolved;
+    // Don't cache a miss: the native host may not be installed yet at first call
+    // (or a headless smoke installs a fake afterwards).
+    const found = getNativeModule(TURBO_MODULE_NAME) ??
+        getNativeModule(LEGACY_MODULE_NAME);
+    if (found !== null)
+        resolved = found;
+    return found;
+}
+// True when the stock native module is present in the binary: the gate the
+// drivers consult before honouring useNativeDriver:true (else they fall back to
+// the JS-driven path of ADR 0016).
+export function isNativeAnimatedAvailable() {
+    return module() !== null;
+}
+let nextNodeTag = 1;
+let nextAnimationId = 1;
+export function generateNativeNodeTag() {
+    return nextNodeTag++;
+}
+export function generateNativeAnimationId() {
+    return nextAnimationId++;
+}
+// JS observation of a native-driven value. While native owns the frames, JS sees
+// no per-frame change, so a JS listener on a native value asks native to stream
+// updates back, which it emits as `onAnimatedValueUpdate` ({tag, value}) on the
+// device event bus. One subscription fans those out to per-tag callbacks. The event
+// NAME is the load-bearing contract with the stock native module (a wrong name is
+// silent headless and dead on device).
+const VALUE_UPDATE_EVENT = 'onAnimatedValueUpdate';
+const valueListeners = new Map();
+let valueUpdateSubscription;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function ensureValueUpdateSubscription() {
+    if (valueUpdateSubscription !== undefined)
+        return;
+    valueUpdateSubscription = new NativeEventEmitter().addListener(VALUE_UPDATE_EVENT, payload => {
+        if (!isRecord(payload))
+            return;
+        const tag = Reflect.get(payload, 'tag');
+        const value = Reflect.get(payload, 'value');
+        if (typeof tag === 'number' && typeof value === 'number') {
+            valueListeners.get(tag)?.(value);
+        }
+    });
+}
+// Thin pass-throughs. Calls are issued synchronously in dependency order
+// (createAnimatedNode before connect before start), so no operation queue is
+// needed on iOS. RN's own non-single-op path calls straight through when its
+// queue is empty. Each guards on availability so a missing module degrades to a
+// logged no-op rather than a throw inside a commit.
+export const nativeAnimated = {
+    createAnimatedNode(tag, config) {
+        module()?.createAnimatedNode(tag, config);
+    },
+    connectAnimatedNodes(parentTag, childTag) {
+        module()?.connectAnimatedNodes(parentTag, childTag);
+    },
+    disconnectAnimatedNodes(parentTag, childTag) {
+        module()?.disconnectAnimatedNodes(parentTag, childTag);
+    },
+    connectAnimatedNodeToView(nodeTag, viewTag) {
+        dlog(`native: connect node=${nodeTag} -> view=${viewTag}`);
+        module()?.connectAnimatedNodeToView(nodeTag, viewTag);
+    },
+    disconnectAnimatedNodeFromView(nodeTag, viewTag) {
+        module()?.disconnectAnimatedNodeFromView(nodeTag, viewTag);
+    },
+    restoreDefaultValues(nodeTag) {
+        dlog(`native: restoreDefaultValues node=${nodeTag}`);
+        module()?.restoreDefaultValues(nodeTag);
+    },
+    dropAnimatedNode(tag) {
+        module()?.dropAnimatedNode(tag);
+    },
+    startAnimatingNode(animationId, nodeTag, config, endCallback) {
+        dlog(`native: startAnimatingNode id=${animationId} node=${nodeTag} type=${config.type}`);
+        module()?.startAnimatingNode(animationId, nodeTag, config, endCallback);
+    },
+    stopAnimation(animationId) {
+        module()?.stopAnimation(animationId);
+    },
+    setAnimatedNodeValue(nodeTag, value) {
+        module()?.setAnimatedNodeValue(nodeTag, value);
+    },
+    setAnimatedNodeOffset(nodeTag, offset) {
+        module()?.setAnimatedNodeOffset(nodeTag, offset);
+    },
+    flattenAnimatedNodeOffset(nodeTag) {
+        module()?.flattenAnimatedNodeOffset(nodeTag);
+    },
+    extractAnimatedNodeOffset(nodeTag) {
+        module()?.extractAnimatedNodeOffset(nodeTag);
+    },
+    startListeningToAnimatedNodeValue(tag) {
+        module()?.startListeningToAnimatedNodeValue(tag);
+    },
+    stopListeningToAnimatedNodeValue(tag) {
+        module()?.stopListeningToAnimatedNodeValue(tag);
+    },
+    // High-level value observation: register a per-tag callback and ask native to
+    // stream this node's updates. The last unsubscribe tears the shared device
+    // subscription down too.
+    startListeningToValue(tag, callback) {
+        ensureValueUpdateSubscription();
+        valueListeners.set(tag, callback);
+        dlog(`native: startListeningToValue node=${tag}`);
+        module()?.startListeningToAnimatedNodeValue(tag);
+    },
+    stopListeningToValue(tag) {
+        valueListeners.delete(tag);
+        module()?.stopListeningToAnimatedNodeValue(tag);
+        if (valueListeners.size === 0 && valueUpdateSubscription !== undefined) {
+            valueUpdateSubscription.remove();
+            valueUpdateSubscription = undefined;
+        }
+    },
+    addAnimatedEventToView(viewTag, eventName, mapping) {
+        module()?.addAnimatedEventToView(viewTag, eventName, mapping);
+    },
+    removeAnimatedEventFromView(viewTag, eventName, animatedNodeTag) {
+        module()?.removeAnimatedEventFromView(viewTag, eventName, animatedNodeTag);
+    },
+};

package/build/animated/operators.d.ts

@@ -0,0 +1,80 @@
+import { AnimatedNode, AnimatedWithChildren } from './graph';
+import { AnimatedInterpolation } from './interpolation-node';
+import type { IInterpolationConfig } from './interpolation';
+import type { INativeNodeConfig, IPlatformConfig } from './native/native-animated';
+export declare class AnimatedAddition extends AnimatedWithChildren {
+    private readonly a;
+    private readonly b;
+    constructor(a: AnimatedNode | number, b: AnimatedNode | number);
+    __getValue(): number;
+    interpolate(config: IInterpolationConfig): AnimatedInterpolation;
+    __attach(): void;
+    __detach(): void;
+    __makeNative(platformConfig?: IPlatformConfig): void;
+    __getNativeConfig(): INativeNodeConfig;
+}
+export declare class AnimatedSubtraction extends AnimatedWithChildren {
+    private readonly a;
+    private readonly b;
+    constructor(a: AnimatedNode | number, b: AnimatedNode | number);
+    __getValue(): number;
+    interpolate(config: IInterpolationConfig): AnimatedInterpolation;
+    __attach(): void;
+    __detach(): void;
+    __makeNative(platformConfig?: IPlatformConfig): void;
+    __getNativeConfig(): INativeNodeConfig;
+}
+export declare class AnimatedMultiplication extends AnimatedWithChildren {
+    private readonly a;
+    private readonly b;
+    constructor(a: AnimatedNode | number, b: AnimatedNode | number);
+    __getValue(): number;
+    interpolate(config: IInterpolationConfig): AnimatedInterpolation;
+    __attach(): void;
+    __detach(): void;
+    __makeNative(platformConfig?: IPlatformConfig): void;
+    __getNativeConfig(): INativeNodeConfig;
+}
+export declare class AnimatedDivision extends AnimatedWithChildren {
+    private readonly a;
+    private readonly b;
+    private warnedAboutDivideByZero;
+    constructor(a: AnimatedNode | number, b: AnimatedNode | number);
+    __getValue(): number;
+    interpolate(config: IInterpolationConfig): AnimatedInterpolation;
+    __attach(): void;
+    __detach(): void;
+    __makeNative(platformConfig?: IPlatformConfig): void;
+    __getNativeConfig(): INativeNodeConfig;
+}
+export declare class AnimatedModulo extends AnimatedWithChildren {
+    private readonly a;
+    private readonly modulus;
+    constructor(a: AnimatedNode, modulus: number);
+    __getValue(): number;
+    interpolate(config: IInterpolationConfig): AnimatedInterpolation;
+    __attach(): void;
+    __detach(): void;
+    __makeNative(platformConfig?: IPlatformConfig): void;
+    __getNativeConfig(): INativeNodeConfig;
+}
+export declare class AnimatedDiffClamp extends AnimatedWithChildren {
+    private readonly a;
+    private readonly min;
+    private readonly max;
+    private value;
+    private lastValue;
+    constructor(a: AnimatedNode, min: number, max: number);
+    __getValue(): number;
+    interpolate(config: IInterpolationConfig): AnimatedInterpolation;
+    __attach(): void;
+    __detach(): void;
+    __makeNative(platformConfig?: IPlatformConfig): void;
+    __getNativeConfig(): INativeNodeConfig;
+}
+export declare function add(a: AnimatedNode | number, b: AnimatedNode | number): AnimatedAddition;
+export declare function subtract(a: AnimatedNode | number, b: AnimatedNode | number): AnimatedSubtraction;
+export declare function multiply(a: AnimatedNode | number, b: AnimatedNode | number): AnimatedMultiplication;
+export declare function divide(a: AnimatedNode | number, b: AnimatedNode | number): AnimatedDivision;
+export declare function modulo(a: AnimatedNode, modulus: number): AnimatedModulo;
+export declare function diffClamp(a: AnimatedNode, min: number, max: number): AnimatedDiffClamp;