@symbiote-native/engine 0.1.0

package/build/animated/animations/timing.d.ts

@@ -0,0 +1,27 @@
+import type { IAnimation, IEndCallback } from '../animation';
+import type { AnimatedValue } from '../value';
+import { type IEasingFunction } from '../easing';
+import type { INativeAnimationConfig } from '../native/native-animated';
+import { BaseAnimation, type IAnimationConfig } from './base';
+export interface ITimingAnimationConfig extends IAnimationConfig {
+    toValue: number;
+    easing?: IEasingFunction;
+    duration?: number;
+    delay?: number;
+}
+export declare class TimingAnimation extends BaseAnimation {
+    private startTime;
+    private fromValue;
+    private readonly toValue;
+    private readonly duration;
+    private readonly delay;
+    private readonly easing;
+    private onUpdate;
+    private animationFrame;
+    private timeout;
+    constructor(config: ITimingAnimationConfig);
+    protected getNativeAnimationConfig(): INativeAnimationConfig;
+    start(fromValue: number, onUpdate: (value: number) => void, onEnd: IEndCallback, _previousAnimation: IAnimation | null, animatedValue: AnimatedValue): void;
+    private onFrame;
+    stop(): void;
+}

package/build/animated/animations/timing.js

@@ -0,0 +1,101 @@
+// TimingAnimation: ported from RN's animations/TimingAnimation.js, JS path
+// only (ADR 0016). Walks a value from `fromValue` to `toValue` over `duration`
+// ms, shaping progress through an easing function. The native-frame export and
+// __startAnimationIfNative branch are dropped.
+import { Easing } from '../easing';
+import { dlog } from '../../debug';
+import { BaseAnimation } from './base';
+import { cancelFrame, clearTimer, requestFrame, setTimer } from './raf';
+let cachedEaseInOut;
+function easeInOut() {
+    if (cachedEaseInOut === undefined) {
+        cachedEaseInOut = Easing.inOut(Easing.ease);
+    }
+    return cachedEaseInOut;
+}
+export class TimingAnimation extends BaseAnimation {
+    startTime = 0;
+    fromValue = 0;
+    toValue;
+    duration;
+    delay;
+    easing;
+    onUpdate = () => { };
+    animationFrame = null;
+    timeout = null;
+    constructor(config) {
+        super(config);
+        this.toValue = config.toValue;
+        this.easing = config.easing ?? easeInOut();
+        this.duration = config.duration ?? 500;
+        this.delay = config.delay ?? 0;
+    }
+    // Native: hand the easing curve to native as a per-frame sample table.
+    getNativeAnimationConfig() {
+        const frameDuration = 1000 / 60;
+        const numFrames = Math.round(this.duration / frameDuration);
+        const frames = [];
+        for (let frame = 0; frame < numFrames; frame++) {
+            frames.push(this.easing(frame / numFrames));
+        }
+        frames.push(this.easing(1));
+        return {
+            type: 'frames',
+            frames,
+            toValue: this.toValue,
+            iterations: this.__iterations,
+            platformConfig: this.__platformConfig,
+            debugID: this.__getDebugID(),
+        };
+    }
+    start(fromValue, onUpdate, onEnd, _previousAnimation, animatedValue) {
+        this.begin(onEnd);
+        this.fromValue = fromValue;
+        this.onUpdate = onUpdate;
+        const begin = () => {
+            this.startTime = Date.now();
+            // Native took over → the JS rAF loop is skipped entirely.
+            if (this.startNativeIfNeeded(animatedValue))
+                return;
+            if (this.duration === 0) {
+                this.onUpdate(this.toValue);
+                this.__notifyAnimationEnd({ finished: true });
+            }
+            else {
+                this.animationFrame = requestFrame(() => this.onFrame());
+            }
+        };
+        if (this.delay !== 0) {
+            this.timeout = setTimer(begin, this.delay);
+        }
+        else {
+            begin();
+        }
+    }
+    onFrame() {
+        const now = Date.now();
+        if (now >= this.startTime + this.duration) {
+            this.onUpdate(this.fromValue + this.easing(1) * (this.toValue - this.fromValue));
+            this.__notifyAnimationEnd({ finished: true });
+            return;
+        }
+        this.onUpdate(this.fromValue +
+            this.easing((now - this.startTime) / this.duration) * (this.toValue - this.fromValue));
+        if (this.__active) {
+            this.animationFrame = requestFrame(() => this.onFrame());
+        }
+    }
+    stop() {
+        super.stop();
+        if (this.timeout !== null) {
+            clearTimer(this.timeout);
+            this.timeout = null;
+        }
+        if (this.animationFrame !== null) {
+            cancelFrame(this.animationFrame);
+            this.animationFrame = null;
+        }
+        dlog('timing animation stopped');
+        this.__notifyAnimationEnd({ finished: false });
+    }
+}

package/build/animated/animations/tracking.d.ts

@@ -0,0 +1,14 @@
+import type { IAnimation, IEndCallback } from '../animation';
+import { AnimatedNode } from '../graph';
+import type { AnimatedValue } from '../value';
+export declare class AnimatedTracking extends AnimatedNode {
+    private readonly value;
+    private readonly parent;
+    private readonly createAnimation;
+    private readonly endCallback?;
+    constructor(value: AnimatedValue, parent: AnimatedNode, createAnimation: (toValue: number) => IAnimation, endCallback?: IEndCallback | undefined);
+    __getValue(): number;
+    __attach(): void;
+    __detach(): void;
+    update(): void;
+}

package/build/animated/animations/tracking.js

@@ -0,0 +1,43 @@
+// AnimatedTracking: drives a value toward a MOVING target. When you write
+// `Animated.spring(value, { toValue: anotherValue })`, the target is itself an
+// AnimatedNode; this node subscribes to it as a leaf child and, each time the
+// target changes, re-launches the animation toward the target's new value, so the
+// value chases the target continuously (a spring following a gesture). Ported from
+// RN's AnimatedTracking.js, JS path; native tracking re-uses the per-launch driver.
+import { AnimatedNode } from '../graph';
+export class AnimatedTracking extends AnimatedNode {
+    value;
+    parent;
+    createAnimation;
+    endCallback;
+    constructor(value, parent, 
+    // Builds a fresh driver aimed at a concrete target value: the config captured
+    // at call time with `toValue` resolved to the parent's current number.
+    createAnimation, endCallback) {
+        super();
+        this.value = value;
+        this.parent = parent;
+        this.createAnimation = createAnimation;
+        this.endCallback = endCallback;
+        // Subscribe to the target immediately (RN does this in the constructor), so a
+        // target change reaches update() even before the first launch.
+        this.__attach();
+    }
+    __getValue() {
+        const target = this.parent.__getValue();
+        return typeof target === 'number' ? target : 0;
+    }
+    __attach() {
+        this.parent.__addChild(this);
+    }
+    __detach() {
+        this.parent.__removeChild(this);
+        super.__detach();
+    }
+    // Leaf seam (a method, never a class field: flushValue detects leaves
+    // structurally and a field would shadow it under useDefineForClassFields). The
+    // target moved: launch a fresh animation toward its new value.
+    update() {
+        this.value.animate(this.createAnimation(this.__getValue()), this.endCallback);
+    }
+}

package/build/animated/bezier.d.ts

@@ -0,0 +1 @@
+export declare function bezier(mX1: number, mY1: number, mX2: number, mY2: number): (x: number) => number;

package/build/animated/bezier.js

@@ -0,0 +1,101 @@
+// Cubic-bezier easing solver, ported verbatim from React Native's
+// Libraries/Animated/bezier.js (originally bezier-easing by Gaëtan Renaudeau,
+// MIT). Pure math (no React, no native), so it lives unchanged in shared.
+// Established by empiricism (tradeoff: performance vs precision).
+const NEWTON_ITERATIONS = 4;
+const NEWTON_MIN_SLOPE = 0.001;
+const SUBDIVISION_PRECISION = 0.0000001;
+const SUBDIVISION_MAX_ITERATIONS = 10;
+const SPLINE_TABLE_SIZE = 11;
+const SAMPLE_STEP_SIZE = 1.0 / (SPLINE_TABLE_SIZE - 1.0);
+function a(a1, a2) {
+    return 1.0 - 3.0 * a2 + 3.0 * a1;
+}
+function b(a1, a2) {
+    return 3.0 * a2 - 6.0 * a1;
+}
+function c(a1) {
+    return 3.0 * a1;
+}
+// x(t) given t, x1, x2, or y(t) given t, y1, y2.
+function calcBezier(t, a1, a2) {
+    return ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;
+}
+// dx/dt given t, x1, x2, or dy/dt given t, y1, y2.
+function getSlope(t, a1, a2) {
+    return 3.0 * a(a1, a2) * t * t + 2.0 * b(a1, a2) * t + c(a1);
+}
+function binarySubdivide(x, lower, upper, mX1, mX2) {
+    let currentX;
+    let currentT;
+    let lo = lower;
+    let hi = upper;
+    let i = 0;
+    do {
+        currentT = lo + (hi - lo) / 2.0;
+        currentX = calcBezier(currentT, mX1, mX2) - x;
+        if (currentX > 0.0) {
+            hi = currentT;
+        }
+        else {
+            lo = currentT;
+        }
+    } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
+    return currentT;
+}
+function newtonRaphsonIterate(x, guess, mX1, mX2) {
+    let guessT = guess;
+    for (let i = 0; i < NEWTON_ITERATIONS; ++i) {
+        const currentSlope = getSlope(guessT, mX1, mX2);
+        if (currentSlope === 0.0) {
+            return guessT;
+        }
+        const currentX = calcBezier(guessT, mX1, mX2) - x;
+        guessT -= currentX / currentSlope;
+    }
+    return guessT;
+}
+export function bezier(mX1, mY1, mX2, mY2) {
+    if (!(mX1 >= 0 && mX1 <= 1 && mX2 >= 0 && mX2 <= 1)) {
+        throw new Error('bezier x values must be in [0, 1] range');
+    }
+    // Precompute the spline samples once.
+    const sampleValues = new Array(SPLINE_TABLE_SIZE);
+    if (mX1 !== mY1 || mX2 !== mY2) {
+        for (let i = 0; i < SPLINE_TABLE_SIZE; ++i) {
+            sampleValues[i] = calcBezier(i * SAMPLE_STEP_SIZE, mX1, mX2);
+        }
+    }
+    function getTForX(x) {
+        let intervalStart = 0.0;
+        let currentSample = 1;
+        const lastSample = SPLINE_TABLE_SIZE - 1;
+        for (; currentSample !== lastSample && sampleValues[currentSample] <= x; ++currentSample) {
+            intervalStart += SAMPLE_STEP_SIZE;
+        }
+        --currentSample;
+        // Interpolate to provide an initial guess for t.
+        const dist = (x - sampleValues[currentSample]) /
+            (sampleValues[currentSample + 1] - sampleValues[currentSample]);
+        const guessForT = intervalStart + dist * SAMPLE_STEP_SIZE;
+        const initialSlope = getSlope(guessForT, mX1, mX2);
+        if (initialSlope >= NEWTON_MIN_SLOPE) {
+            return newtonRaphsonIterate(x, guessForT, mX1, mX2);
+        }
+        if (initialSlope === 0.0) {
+            return guessForT;
+        }
+        return binarySubdivide(x, intervalStart, intervalStart + SAMPLE_STEP_SIZE, mX1, mX2);
+    }
+    return function bezierEasing(x) {
+        if (mX1 === mY1 && mX2 === mY2) {
+            return x; // linear
+        }
+        // JS numbers are imprecise; pin the extremes.
+        if (x === 0)
+            return 0;
+        if (x === 1)
+            return 1;
+        return calcBezier(getTForX(x), mY1, mY2);
+    };
+}

package/build/animated/color.d.ts

@@ -0,0 +1,37 @@
+import { AnimatedWithChildren } from './graph';
+import { AnimatedValue } from './value';
+import type { INativeNodeConfig, IPlatformConfig } from './native/native-animated';
+export interface IRgbaValue {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+type IChannel = number | AnimatedValue;
+interface IRgbaInput {
+    r: IChannel;
+    g: IChannel;
+    b: IChannel;
+    a: IChannel;
+}
+export type IColorInput = IRgbaInput | IRgbaValue | string | number;
+export declare function normalizeColor(color: string | number): IRgbaValue | undefined;
+export declare class AnimatedColor extends AnimatedWithChildren {
+    readonly r: AnimatedValue;
+    readonly g: AnimatedValue;
+    readonly b: AnimatedValue;
+    readonly a: AnimatedValue;
+    constructor(value?: IColorInput);
+    __getValue(): string;
+    setValue(value: IRgbaValue | string | number): void;
+    setOffset(offset: IRgbaValue): void;
+    flattenOffset(): void;
+    extractOffset(): void;
+    stopAnimation(callback?: (value: string) => void): void;
+    __callListeners(_value: number | string): void;
+    __attach(): void;
+    __detach(): void;
+    __makeNative(platformConfig?: IPlatformConfig): void;
+    __getNativeConfig(): INativeNodeConfig;
+}
+export {};

package/build/animated/color.js

@@ -0,0 +1,183 @@
+// AnimatedColor: animate a color by driving four channel values (r, g, b, a). Its
+// __getValue() is an `rgba(...)` string, which the commit layer's injected color
+// processor turns into the platform int Fabric wants. Ported from RN's
+// AnimatedColor.js: the {r,g,b,a} and CSS-color input forms are supported; named
+// colors and platform (Native) colors are deferred (they need RN's full
+// normalizeColor / processColorObject, which live outside shared).
+import { AnimatedWithChildren, flushValue } from './graph';
+import { AnimatedValue } from './value';
+const DEFAULT_COLOR = { r: 0, g: 0, b: 0, a: 1 };
+function isRgbaInput(value) {
+    return typeof value === 'object' && value !== null && 'r' in value && 'g' in value;
+}
+function toChannel(value) {
+    return value instanceof AnimatedValue ? value : new AnimatedValue(value);
+}
+// Decompose a #hex (3/4/6/8), rgb()/rgba(), or 0xRRGGBBAA number into channels.
+// undefined when unparseable (a named/platform color), so the caller falls back to
+// the default rather than throwing inside a render. Exported so interpolation's
+// color path parses through the same RGBA decoder (DRY) rather than duplicating it.
+export function normalizeColor(color) {
+    if (typeof color === 'number') {
+        const c = color >>> 0;
+        return { r: (c >>> 24) & 255, g: (c >>> 16) & 255, b: (c >>> 8) & 255, a: (c & 255) / 255 };
+    }
+    const trimmed = color.trim();
+    if (trimmed.startsWith('#'))
+        return parseHex(trimmed);
+    if (/^rgba?\(/i.test(trimmed))
+        return parseRgb(trimmed);
+    return undefined;
+}
+function parseHex(hex) {
+    let body = hex.slice(1);
+    if (body.length === 3 || body.length === 4) {
+        body = body
+            .split('')
+            .map(c => c + c)
+            .join('');
+    }
+    if (body.length !== 6 && body.length !== 8)
+        return undefined;
+    const int = Number.parseInt(body, 16);
+    if (Number.isNaN(int))
+        return undefined;
+    if (body.length === 6) {
+        return { r: (int >>> 16) & 255, g: (int >>> 8) & 255, b: int & 255, a: 1 };
+    }
+    const c = int >>> 0;
+    return { r: (c >>> 24) & 255, g: (c >>> 16) & 255, b: (c >>> 8) & 255, a: (c & 255) / 255 };
+}
+function parseRgb(str) {
+    const match = /^rgba?\(([^)]+)\)$/i.exec(str);
+    if (match === null)
+        return undefined;
+    const parts = match[1].split(',').map(part => Number.parseFloat(part.trim()));
+    if (parts.length < 3 || parts.some(n => Number.isNaN(n)))
+        return undefined;
+    return { r: parts[0], g: parts[1], b: parts[2], a: parts.length >= 4 ? parts[3] : 1 };
+}
+// Resolve any input form to four concrete channel values (numbers or pre-built
+// AnimatedValues), so the constructor can wrap each in an AnimatedValue.
+function resolveInput(value) {
+    if (value === undefined)
+        return DEFAULT_COLOR;
+    if (typeof value === 'string' || typeof value === 'number') {
+        return normalizeColor(value) ?? DEFAULT_COLOR;
+    }
+    if (isRgbaInput(value))
+        return value;
+    return DEFAULT_COLOR;
+}
+export class AnimatedColor extends AnimatedWithChildren {
+    r;
+    g;
+    b;
+    a;
+    constructor(value) {
+        super();
+        const input = resolveInput(value);
+        this.r = toChannel(input.r);
+        this.g = toChannel(input.g);
+        this.b = toChannel(input.b);
+        this.a = toChannel(input.a);
+    }
+    // The CSS color string the commit layer's color processor converts to a platform
+    // int. Channels are rounded; alpha stays fractional.
+    __getValue() {
+        const r = Math.round(numericValue(this.r));
+        const g = Math.round(numericValue(this.g));
+        const b = Math.round(numericValue(this.b));
+        const a = numericValue(this.a);
+        return `rgba(${r}, ${g}, ${b}, ${a})`;
+    }
+    // Each per-channel setValue/setOffset flushes bound props and walks the graph
+    // up to this color node's listeners. Driving four channels in a row would
+    // otherwise commit the bound view four times and fire color listeners four
+    // times, each with an intermediate rgba() that never logically existed. So we
+    // suspend this node's listeners across all four writes, then do ONE flush and
+    // ONE listener fire with the final composed color (RN's _withSuspendedCallbacks
+    // pattern). flushValue dedupes by leaf identity, so a single flush rebuilds
+    // every bound prop once even though four channels changed.
+    setValue(value) {
+        const rgba = typeof value === 'object' ? value : (normalizeColor(value) ?? DEFAULT_COLOR);
+        this.withSuspendedCallbacks(() => {
+            this.r.setValue(rgba.r);
+            this.g.setValue(rgba.g);
+            this.b.setValue(rgba.b);
+            this.a.setValue(rgba.a);
+        });
+        flushValue(this);
+        this.__callListeners(this.__getValue());
+    }
+    // setOffset / flattenOffset / extractOffset do NOT flush or fire listeners in
+    // symbiote's per-channel AnimatedValue (offset writes are silent), so there is
+    // no 4×-fire to suspend here, matching RN, where only setValue suspends.
+    setOffset(offset) {
+        this.r.setOffset(offset.r);
+        this.g.setOffset(offset.g);
+        this.b.setOffset(offset.b);
+        this.a.setOffset(offset.a);
+    }
+    flattenOffset() {
+        this.r.flattenOffset();
+        this.g.flattenOffset();
+        this.b.flattenOffset();
+        this.a.flattenOffset();
+    }
+    extractOffset() {
+        this.r.extractOffset();
+        this.g.extractOffset();
+        this.b.extractOffset();
+        this.a.extractOffset();
+    }
+    stopAnimation(callback) {
+        this.r.stopAnimation();
+        this.g.stopAnimation();
+        this.b.stopAnimation();
+        this.a.stopAnimation();
+        callback?.(this.__getValue());
+    }
+    // A color listener wants the composed rgba() string, not the bare channel number
+    // the child-walk arrives with. So we ignore the incoming value and re-pull
+    // __getValue(). super.__callListeners honors the suspend counter, so during
+    // setValue's four channel writes this is a no-op and the only fire is the
+    // explicit final one below.
+    __callListeners(_value) {
+        super.__callListeners(this.__getValue());
+    }
+    __attach() {
+        this.r.__addChild(this);
+        this.g.__addChild(this);
+        this.b.__addChild(this);
+        this.a.__addChild(this);
+        super.__attach();
+    }
+    __detach() {
+        this.r.__removeChild(this);
+        this.g.__removeChild(this);
+        this.b.__removeChild(this);
+        this.a.__removeChild(this);
+        super.__detach();
+    }
+    __makeNative(platformConfig) {
+        this.r.__makeNative(platformConfig);
+        this.g.__makeNative(platformConfig);
+        this.b.__makeNative(platformConfig);
+        this.a.__makeNative(platformConfig);
+        super.__makeNative(platformConfig);
+    }
+    __getNativeConfig() {
+        return {
+            type: 'color',
+            r: this.r.__getNativeTag(),
+            g: this.g.__getNativeTag(),
+            b: this.b.__getNativeTag(),
+            a: this.a.__getNativeTag(),
+        };
+    }
+}
+function numericValue(node) {
+    const value = node.__getValue();
+    return typeof value === 'number' ? value : 0;
+}

package/build/animated/easing.d.ts

@@ -0,0 +1,20 @@
+export type IEasingFunction = (t: number) => number;
+export declare const 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): IEasingFunction;
+    sin(t: number): number;
+    circle(t: number): number;
+    exp(t: number): number;
+    elastic(bounciness?: number): IEasingFunction;
+    back(s?: number): IEasingFunction;
+    bounce(t: number): number;
+    bezier(x1: number, y1: number, x2: number, y2: number): IEasingFunction;
+    in(easing: IEasingFunction): IEasingFunction;
+    out(easing: IEasingFunction): IEasingFunction;
+    inOut(easing: IEasingFunction): IEasingFunction;
+};

package/build/animated/easing.js

@@ -0,0 +1,96 @@
+// Common easing functions, ported from React Native's Libraries/Animated/Easing.js.
+// Pure math (the only dependency is the equally-pure bezier solver), so it lives
+// unchanged in shared and every adapter re-exports it.
+import { bezier } from './bezier';
+let cachedEase;
+export const Easing = {
+    // A stepping function: 1 for any positive n, else 0.
+    step0(n) {
+        return n > 0 ? 1 : 0;
+    },
+    // A stepping function: 1 once n >= 1, else 0.
+    step1(n) {
+        return n >= 1 ? 1 : 0;
+    },
+    // Linear, f(t) = t.
+    linear(t) {
+        return t;
+    },
+    // A simple inertial interaction (object slowly accelerating to speed).
+    ease(t) {
+        if (cachedEase === undefined) {
+            cachedEase = bezier(0.42, 0, 1, 1);
+        }
+        return cachedEase(t);
+    },
+    // Quadratic, f(t) = t * t.
+    quad(t) {
+        return t * t;
+    },
+    // Cubic, f(t) = t * t * t.
+    cubic(t) {
+        return t * t * t;
+    },
+    // Nth-power: position is the Nth power of elapsed time.
+    poly(n) {
+        return t => Math.pow(t, n);
+    },
+    // Sinusoidal.
+    sin(t) {
+        return 1 - Math.cos((t * Math.PI) / 2);
+    },
+    // Circular.
+    circle(t) {
+        return 1 - Math.sqrt(1 - t * t);
+    },
+    // Exponential.
+    exp(t) {
+        return Math.pow(2, 10 * (t - 1));
+    },
+    // Elastic: spring-like oscillation. bounciness 1 overshoots once; 0 not at all.
+    elastic(bounciness = 1) {
+        const p = bounciness * Math.PI;
+        return t => 1 - Math.pow(Math.cos((t * Math.PI) / 2), 3) * Math.cos(t * p);
+    },
+    // Animates back slightly before moving forward.
+    back(s = 1.70158) {
+        return t => t * t * ((s + 1) * t - s);
+    },
+    // A simple bouncing effect.
+    bounce(t) {
+        if (t < 1 / 2.75) {
+            return 7.5625 * t * t;
+        }
+        if (t < 2 / 2.75) {
+            const t2 = t - 1.5 / 2.75;
+            return 7.5625 * t2 * t2 + 0.75;
+        }
+        if (t < 2.5 / 2.75) {
+            const t2 = t - 2.25 / 2.75;
+            return 7.5625 * t2 * t2 + 0.9375;
+        }
+        const t2 = t - 2.625 / 2.75;
+        return 7.5625 * t2 * t2 + 0.984375;
+    },
+    // A cubic bezier curve, same as CSS transition-timing-function.
+    bezier(x1, y1, x2, y2) {
+        return bezier(x1, y1, x2, y2);
+    },
+    // Runs an easing function forwards.
+    in(easing) {
+        return easing;
+    },
+    // Runs an easing function backwards.
+    out(easing) {
+        return t => 1 - easing(1 - t);
+    },
+    // Makes any easing function symmetrical (forwards then backwards).
+    inOut(easing) {
+        return t => {
+            if (t < 0.5) {
+                return easing(t * 2) / 2;
+            }
+            return 1 - easing((1 - t) * 2) / 2;
+        };
+    },
+};

package/build/animated/event.d.ts

@@ -0,0 +1,36 @@
+import { type ISymbioteNode } from '../node';
+import { AnimatedNode } from './graph';
+type IMapping = AnimatedNode | {
+    readonly [key: string]: IMapping;
+};
+export interface IEventConfig {
+    readonly listener?: (...args: unknown[]) => void;
+    readonly useNativeDriver?: boolean;
+}
+export interface IAnimatedEventHandler {
+    (...args: unknown[]): void;
+    __getEvent(): AnimatedEvent;
+}
+export type IEventListener = (...args: unknown[]) => void;
+export declare class AnimatedEvent {
+    private readonly listeners;
+    private readonly mappedValues;
+    private readonly nativeDriverRequested;
+    private attachedNatively;
+    constructor(argMapping: readonly IMapping[], config?: IEventConfig);
+    __addListener(callback: IEventListener): void;
+    __removeListener(callback: IEventListener): void;
+    __isNative(): boolean;
+    __attach(viewTag: number, eventName: string): void;
+    __detach(viewTag: number, eventName: string): void;
+    __getHandler(): IAnimatedEventHandler;
+}
+export declare function event(argMapping: readonly IMapping[], config?: IEventConfig): IAnimatedEventHandler;
+export interface INativeEventAttachment {
+    detach(): void;
+}
+export declare function attachNativeEvent(node: ISymbioteNode, eventName: string, argMapping: readonly IMapping[]): INativeEventAttachment;
+export declare function attachNativeEventHandler(node: unknown, eventName: string, handler: unknown): INativeEventAttachment | undefined;
+export declare function forkEvent(existing: IAnimatedEventHandler | IEventListener | undefined, listener: IEventListener): IAnimatedEventHandler | IEventListener;
+export declare function unforkEvent(existing: IAnimatedEventHandler | IEventListener | undefined, listener: IEventListener): void;
+export {};