import * as React from 'react';
import { type MarqueeSyncController, type MarqueeWallFadeEdge, type MarqueeWallProps } from '../ui/marquee-wall';
import { type QuickActionThemeSpec, type QuickActionChip } from './quick-action-chip';
/** Skeleton label widths (ch) — realistic spread, cycled. THE wall-skeleton
 *  spread, shared with the company-hub deck's ChipWall: sized so a 24-item
 *  wall overflows typical caps at any viewport width (same fill + fade as
 *  the loaded state — zero height jump when data lands). */
export declare const WALL_SKELETON_LABEL_CH: number[];
/** Deterministic index-alternating merge — the mixed "one stream" pile
 *  (deck slide 3's IT+SEC blend and its Storybook mirror). Input order
 *  stable → the blend never reshuffles across renders or consumers. */
export declare function interleave<T>(a: ReadonlyArray<T>, b: ReadonlyArray<T>): T[];
export interface QuickActionWallProps {
    /** The wall's chips — the shared {@link QuickActionChip} shape (same as the
     *  chat rows), including per-chip `theme`/`lozenge` for mixed IT/SEC
     *  streams. Chips with `onSelect` render as buttons; without, as tags. */
    chips: ReadonlyArray<QuickActionChip>;
    /** Wall-default {@link QuickActionThemeSpec} for chips without their own.
     *  Caller-supplied — the lib ships no theme registry; resolve agent colors
     *  server-side (e.g. `accentFromIdentityIcon`) and pass the spec here. */
    theme?: QuickActionThemeSpec;
    /** `'animated'` (default): marquee + overflow fades. `'plain'`: no motion,
     *  no blur — the consumer's per-surface opt-out (forwarded to
     *  {@link MarqueeWall}; in brick mode the rows render static and the
     *  stack-level fades are skipped). */
    mode?: 'animated' | 'plain';
    /** Render every chip's theme lozenge (classification walls). Per-chip
     *  `lozenge` values still win. */
    lozenges?: boolean;
    /** Marquee axis — defaults to where `fade` sits (see {@link MarqueeWall}). */
    axis?: MarqueeWallProps['axis'];
    reverse?: boolean;
    /** px/s. Default 40 (MarqueeWall default). */
    speed?: number;
    /** Marquee on/off (auto-off when content fits / reduced motion / loading). */
    animate?: boolean;
    pauseOnHover?: boolean;
    /** Opt-in manual drag + wheel scroll (forwarded to {@link MarqueeWall}) — the
     *  auto-marquee pauses while the user drags/wheels and resumes from there.
     *  Enabled on the embeddable-chat quick-action walls. */
    dragScroll?: boolean;
    fade?: MarqueeWallFadeEdge | ReadonlyArray<MarqueeWallFadeEdge>;
    /** Color behind the wall — the fades blend into it. */
    fadeColor?: string;
    fadeSize?: MarqueeWallProps['fadeSize'];
    /** THE wall pitch — one value drives the chip gap, the clone-seam gap, and
     *  (in brick mode) the row-stack gap, so the courses read as a uniform wall
     *  and the seam is invisible by construction. Default
     *  `var(--spacing-system-xsf)`. */
    copyGap?: number | string;
    /** Pad the track by REPEATING the chips up to this count (suffixed keys) so
     *  one copy always overflows the container and the loop engages — without
     *  it a wall whose content roughly fits its box goes static (the marquee
     *  only loops what overflows). Defaults to `rows × 14` in brick mode;
     *  unset otherwise (capped walls that always overflow, and FLIP-tracked
     *  walls where repeats would duplicate flip ids, need no padding). */
    minChips?: number;
    /**
     * BRICK-WALL mode: the MAXIMUM number of stacked single-row marquees. The
     * actual row count grows with the chip supply — `ceil(chips / 14)` capped at
     * `rows` — so a short action set fills one row (padded with its own repeats)
     * instead of spreading one chip per row. The originals are split evenly
     * ACROSS the active rows first, THEN each row pads to a full course, so no
     * row is ever all-duplicates while another holds the unique chips. Rows pack
     * edge-to-edge like bricks (a grid would column-align mismatched widths and
     * leave holes) and each loops on its own wrap. Horizontal only; the fades
     * draw ONCE over the whole stack.
     */
    rows?: number;
    /**
     * Chat agent this wall belongs to (`'fae'` / `'mingo'`). When set to a
     * built-in agent it caps the brick stack at {@link AGENT_MAX_ROWS} (2) so the
     * actions stay compact above the composer; any other value (or unset) leaves
     * the cap at `rows`. Optional — decorative/marketing walls omit it.
     */
    agentSlug?: string;
    /** Draw skeleton chips instead of `chips` (the shared
     *  {@link QuickActionChipSkeleton} — 1:1 geometry with loaded chips).
     *  Callers own the policy (`loading` flag vs skeleton-when-empty). */
    loading?: boolean;
    skeletonCount?: number;
    /** Outer container (sizing: height cap for vertical walls). */
    className?: string;
    /** Per-copy layout — default a wrapping chip wall. Override for single-row
     *  marquee strips (`flex-nowrap`). */
    contentClassName?: string;
    /** Pair with sibling walls under one position driver (resolve strips). */
    sync?: MarqueeSyncController;
}
/**
 * <QuickActionWall> — THE quick-action chip wall: a themed pile of the shared
 * chip on the shared {@link MarqueeWall} engine. One component for every
 * surface that shows "the work the agents do" — homepage hero tabs, deck
 * panels, marketing strips — whether static-with-fade or endlessly scrolling
 * (axis follows the fade), interactive or decorative.
 *
 * Clone-copy chips stay INTERACTIVE (pointer cursor + working click) — the
 * loop paints clones inside the viewport (reverse walls even START on the
 * clone copy), and a visible chip that ignores clicks reads as broken. A11y
 * holds via the clone wrapper: aria-hidden + focus suppression (the standard
 * Swiper/Splide loop-clone treatment, same as CardsStrip). `pauseOnHover`
 * (default on) freezes the track under a pointing cursor so chips never
 * dodge a click.
 */
export declare function QuickActionWall({ chips, theme, mode, lozenges, axis, reverse, speed, animate, pauseOnHover, dragScroll, fade, fadeColor, fadeSize, copyGap, minChips, rows, agentSlug, loading, skeletonCount, className, contentClassName, sync, }: QuickActionWallProps): React.JSX.Element;
//# sourceMappingURL=quick-action-wall.d.ts.map