import * as React from 'react';
export type MarqueeWallFadeEdge = 'top' | 'bottom' | 'left' | 'right';
/** @internal per-instance sync membership (transform writer + driver-role
 *  promotion callback, so a surviving member can be re-elected). */
interface MarqueeSyncMember {
    apply: (pos: number) => void;
    makeDriver: () => void;
}
/**
 * Pairs two (or more) <MarqueeWall> instances to ONE position driver so their
 * tracks stay pixel-locked (the FreeTrialCTA resolve strips: a pending and a
 * resolved copy of the same chips, clip-path'd at the avatar line). The first
 * mounted instance claims the driver role and runs the shared rAF; the others
 * only register their `apply` transforms. If the driver unmounts while
 * members survive, the next member is promoted — the pair must merely be
 * geometry-identical while mounted together.
 */
export interface MarqueeSyncController {
    /** @internal registered members in mount order. */
    members: Set<MarqueeSyncMember>;
    /** @internal current driver member. */
    driver: MarqueeSyncMember | null;
    /** @internal last driver-written position — a promoted driver's engine
     *  seeds from it, so re-election never snaps the pair back to 0. */
    position: number;
}
export declare function useMarqueeSync(): MarqueeSyncController;
export interface MarqueeTrackOffset {
    /** Applied translation (px) along each axis. */
    x: number;
    y: number;
    /** Loop wrap size (single copy + seam gap) along each axis; 0 on the
     *  non-scroll axis. Lets morph engines treat a chip and its loop clone as
     *  ONE identity `wrap` apart (the Swiper loop-clone model) and fly the
     *  copy the viewer actually sees. */
    wrapX: number;
    wrapY: number;
}
/** Last known translation + wrap of the wall registered under `trackId`
 *  (live or already unmounted). Zeros for unknown ids / static walls. */
export declare function getMarqueeTrackOffset(trackId: string): MarqueeTrackOffset;
/**
 * The translation ACTUALLY applied to a wall's track right now, read from the
 * DOM of the `data-marquee-track` container. Morph engines use this on the
 * CAPTURE side (never the registry): a same-id wall freshly remounted in the
 * current commit has not applied any transform yet, while the registry still
 * holds its predecessor's final drift for the flight-side lookup.
 */
export declare function getMarqueeAppliedOffset(trackContainer: Element): {
    x: number;
    y: number;
};
/**
 * The loop-clone twin of an element inside a wall's PRIMARY copy (same index
 * in the `data-marquee-copy="clone"` copy), or null when there is no clone /
 * the element isn't in the primary copy. Owns the wall's internal DOM shape
 * so morph engines don't hardcode it; `selector` scopes which descendants
 * count as items (default: direct structure-preserving lookup by class is the
 * caller's job — pass the item selector, e.g. `'.flipchip'`).
 */
export declare function getMarqueeCloneTwin(trackContainer: Element, el: Element, selector: string): HTMLElement | null;
export interface MarqueeWallProps {
    /**
     * Presentation mode — the consumer's one switch for "do I want the
     * blur + marquee here at all":
     * - `'animated'` (default): endless marquee when content overflows, with
     *   the overflow fades.
     * - `'plain'`: no motion, no fades — a plain clipped wall. All marquee
     *   machinery (engine, clone copy, fades) is skipped entirely.
     */
    mode?: 'animated' | 'plain';
    /**
     * Marquee axis. Defaults to where the fade sits — the animation's job is to
     * reveal what the fade hides: a `bottom`/`top` fade clips rows → vertical
     * (content travels bottom→top); a `left`/`right`-only fade clips columns →
     * horizontal (content travels right→left). No fade → horizontal.
     */
    axis?: 'x' | 'y';
    /** Reverse travel: `x` reversed moves content right, `y` reversed moves it
     *  down. Default false (left / up). */
    reverse?: boolean;
    /** Scroll speed in px/s (the CardsStrip unit — one speed language across
     *  every marquee). Default 40: calm chip-wall drift, slower than the 60 the
     *  card strips cruise at. */
    speed?: number;
    /** Master switch. Even when true the marquee auto-disables while the content
     *  fits the container and under `prefers-reduced-motion` (static wall). */
    animate?: boolean;
    /** Freeze while a hover-capable pointer is anywhere over the wall — content
     *  must never move under a pointing cursor (required for interactive chip
     *  walls). Default true. */
    pauseOnHover?: boolean;
    /** Opt-in MANUAL scroll: pointer-drag + horizontal wheel move the wall along
     *  its axis (transform-based — no inner scroller is created, so it stays
     *  deck-safe). The auto-marquee pauses during the interaction and briefly
     *  after, then resumes drifting from wherever the user left it. Off by
     *  default (decorative walls stay auto-only); enabled on the embeddable-chat
     *  quick-action walls so users can browse the actions by hand. */
    dragScroll?: boolean;
    /** Edge fade(s) — the "there's more" affordance. ONE spelling of the
     *  clip-and-fade across every wall surface. */
    fade?: MarqueeWallFadeEdge | ReadonlyArray<MarqueeWallFadeEdge>;
    /** The color the fades blend INTO — must match the surface behind the wall
     *  or the gradient paints a visible box. Default the page background. */
    fadeColor?: string;
    /** Fade thickness: one value for all edges or a per-edge map. Defaults:
     *  40px vertical edges, 112px horizontal edges (the shipped hero-wall
     *  geometry). */
    fadeSize?: number | string | Partial<Record<MarqueeWallFadeEdge, number | string>>;
    /** Gap between the two track copies — match the content's own item gap so
     *  the seam is invisible. A CSS length string (e.g. `var(--tlcl-chipgap)`)
     *  lets responsive CSS own the value; the true seam distance is MEASURED
     *  from the rendered copies either way. Default 8. */
    copyGap?: number | string;
    /** Outer container class — sizing lives here (height cap for `y`, width for
     *  `x`). The container is always `relative overflow-hidden`. */
    className?: string;
    /** Class on EACH track copy — the wall's own layout (e.g. a wrapping chip
     *  row `flex flex-wrap gap-2`, or a fixed-width grid). */
    contentClassName?: string;
    /** Inline style on EACH track copy — for values classes can't carry (e.g.
     *  an item gap driven by the same variable as `copyGap`, so chip pitch and
     *  seam pitch stay one value by construction). */
    contentStyle?: React.CSSProperties;
    /**
     * Wall content — ONE copy; the wall clones it for the endless loop (clone
     * `aria-hidden` + focus-suppressed but still clickable). Pass a render
     * callback to vary the clone copy (e.g. omit `data-flip-id`s / render
     * decorative chips). Children must be clone-safe: ref-free, unique-DOM-id-
     * free, mount-effect-free (same contract as <CardsStrip> children mode).
     */
    children: React.ReactNode | ((ctx: {
        isClone: boolean;
    }) => React.ReactNode);
    /** Pair this wall with sibling walls under one shared position driver. */
    sync?: MarqueeSyncController;
    /** Stable id for FLIP coordination: publishes the wall's live offset via
     *  {@link getMarqueeTrackOffset} and stamps `data-marquee-track` on the
     *  container so morph engines can drift-correct captured positions. */
    trackId?: string;
}
/** The wall's edge-fade overlays — exported so composite walls (stacked row
 *  marquees) can draw ONE set of fades over the whole stack instead of
 *  per-row copies. Parent must be `relative`. Overlays sit at z-1, ABOVE
 *  FLIP flight ghosts (z-0 by contract): an in-flight chip dissolves under
 *  the blur exactly like a resting chip. */
export declare function MarqueeWallFades({ fade, fadeColor, fadeSize, }: {
    fade?: MarqueeWallFadeEdge | ReadonlyArray<MarqueeWallFadeEdge>;
    fadeColor?: string;
    fadeSize?: MarqueeWallProps['fadeSize'];
}): React.JSX.Element;
/**
 * <MarqueeWall> — THE endless-scroll wall container: a clipped area whose
 * content loops as a marquee along either axis, fading out where the clip
 * cuts. Built on the same `useMarqueeEngine` core as <CardsStrip> (the news /
 * logo / bites strips) with a TRANSFORM driver instead of a scroller — no
 * inner scrollable area is created, so it is safe inside surfaces that forbid
 * nested scrollers (the deck's mobile single-fold panels).
 *
 * Static by circumstance, not by variant: when the content fits the container
 * (or `prefers-reduced-motion`) the wall renders a single static copy with
 * its fades — byte-identical to the old non-animated walls.
 */
export declare function MarqueeWall({ mode, axis: axisProp, reverse, speed, animate, pauseOnHover, dragScroll, fade, fadeColor, fadeSize, copyGap, className, contentClassName, contentStyle, children, sync, trackId, }: MarqueeWallProps): React.JSX.Element;
export {};
//# sourceMappingURL=marquee-wall.d.ts.map