af-motion 0.0.0-stage → 1.0.0

package/dist/core/layout/controller.d.ts

@@ -0,0 +1,56 @@
+/**
+ * AF Motion Automatic Layout Controller
+ *
+ * Encapsulates automatic observation (ResizeObserver / MutationObserver),
+ * FLIP delta calculations, retargeting, and lifecycle management for a DOM element.
+ */
+import type { AnimationControls } from "../animation.js";
+import type { LayoutController, LayoutControllerOptions, LayoutControllerState, LayoutRect, LayoutTransitionOptions } from "./types.js";
+export declare class LayoutControllerImpl implements LayoutController {
+    readonly id: string;
+    readonly element: HTMLElement;
+    private options;
+    private previousRect;
+    private currentControls;
+    private lastDelta;
+    private isDestroyed;
+    private isProcessingObservation;
+    private animating;
+    private currentProgress;
+    private resizeObserver;
+    private mutationObserver;
+    private rafId;
+    constructor(element: HTMLElement, options?: LayoutControllerOptions);
+    getState(): LayoutControllerState;
+    getBounds(): LayoutRect | null;
+    isAnimating(): boolean;
+    /**
+     * Reads and updates the current layout measurement.
+     */
+    measure(): LayoutRect;
+    /**
+     * Records the "First" layout rectangle before a DOM or state change.
+     */
+    record(): LayoutRect;
+    /**
+     * Retargets an active animation to a new destination rectangle smoothly.
+     */
+    retarget(newTargetRect?: LayoutRect): void;
+    /**
+     * Executes FLIP layout animation from recorded previousRect to current DOM layout.
+     */
+    animate(overrideOptions?: Partial<LayoutTransitionOptions>): AnimationControls | null;
+    updateOptions(options: Partial<LayoutControllerOptions>): void;
+    play(): void;
+    pause(): void;
+    cancel(): void;
+    finish(): void;
+    destroy(): void;
+    private setupObservers;
+    private teardownObservers;
+    private scheduleLayoutCheck;
+}
+/**
+ * Creates and returns a production-grade layout controller for an element.
+ */
+export declare function createLayoutController(element: HTMLElement, options?: LayoutControllerOptions): LayoutController;

package/dist/core/layout/flip.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AF Motion FLIP (First, Last, Invert, Play) Engine
+ *
+ * Mathematically sound delta calculations, inverse transform generation,
+ * and seamless layout transition execution.
+ */
+import { type AnimatableProperties } from "../animate.js";
+import type { AnimationControls } from "../animation.js";
+import type { LayoutDelta, LayoutRect, LayoutTransitionOptions } from "./types.js";
+/**
+ * Computes the FLIP delta between First and Last layout geometries.
+ */
+export declare function computeFLIPDelta(first: LayoutRect, last: LayoutRect, options?: LayoutTransitionOptions): LayoutDelta;
+/**
+ * Builds animatable CSS keyframes for the inverse FLIP transform.
+ */
+export declare function createFLIPKeyframes(delta: LayoutDelta, options?: LayoutTransitionOptions): AnimatableProperties;
+/**
+ * Animates a layout change from a previously captured bounding rectangle to its current layout.
+ */
+export declare function animateLayoutChange(element: HTMLElement, fromRect: LayoutRect, options?: LayoutTransitionOptions): AnimationControls | null;

package/dist/core/layout/group.d.ts

@@ -0,0 +1,46 @@
+/**
+ * AF Motion Layout Group Coordination
+ *
+ * Coordinates multi-element layout transitions, batch measurement cycles,
+ * and customizable staggering without layout thrashing.
+ */
+import type { AnimationControls } from "../animation.js";
+import type { LayoutController, LayoutControllerOptions, LayoutGroup, LayoutGroupOptions, LayoutRect } from "./types.js";
+export declare class LayoutGroupImpl implements LayoutGroup {
+    readonly id: string;
+    private options;
+    private members;
+    private elementToId;
+    private isDestroyed;
+    constructor(options?: LayoutGroupOptions);
+    add(elementOrController: HTMLElement | LayoutController, options?: Partial<LayoutControllerOptions>): LayoutController;
+    remove(elementOrId: HTMLElement | string): void;
+    get(elementOrId: HTMLElement | string): LayoutController | undefined;
+    getAll(): readonly LayoutController[];
+    /**
+     * Reads layout rects for all members in a single batched pass.
+     */
+    measureAll(): Map<string, LayoutRect>;
+    /**
+     * Records the initial "First" layout rect for all members in a single batched pass.
+     */
+    recordAll(): void;
+    /**
+     * Computes stagger delays and executes FLIP transitions across all member elements.
+     */
+    animateAll(overrideOptions?: Partial<LayoutGroupOptions>): readonly AnimationControls[];
+    updateOptions(options: Partial<LayoutGroupOptions>): void;
+    cancelAll(): void;
+    destroy(): void;
+}
+/**
+ * Creates and returns a coordinated multi-element layout group.
+ */
+export declare function createLayoutGroup(options?: LayoutGroupOptions): LayoutGroup;
+/**
+ * Performs a batch layout update safely:
+ * 1. Read phase: Record all First rects.
+ * 2. Mutation phase: Run DOM mutation callback.
+ * 3. Animate phase: Measure Last rects and animate FLIP transitions.
+ */
+export declare function batchLayoutUpdate(updateFn: () => void, groupOrControllers: LayoutGroup | readonly LayoutController[]): readonly AnimationControls[];

package/dist/core/layout/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * AF Motion Automatic Layout Animation Engine
+ *
+ * Production-grade automatic layout detection, FLIP calculations,
+ * coordinated layout groups, and seamless transitions.
+ */
+export * from "./types.js";
+export * from "./presets.js";
+export * from "./measure.js";
+export * from "./flip.js";
+export * from "./controller.js";
+export * from "./group.js";

package/dist/core/layout/measure.d.ts

@@ -0,0 +1,30 @@
+/**
+ * AF Motion Layout Measurement Utilities
+ *
+ * Fast, batch-safe geometric measurements with scroll awareness
+ * and zero layout thrashing.
+ */
+import type { LayoutRect } from "./types.js";
+/**
+ * Computes current viewport scroll offsets safely across browser environments.
+ */
+export declare function getViewportScroll(): {
+    x: number;
+    y: number;
+};
+/**
+ * Measures the bounding rectangle of an element, optionally accounting for page scroll.
+ */
+export declare function measureLayout(element: HTMLElement, includeScroll?: boolean): LayoutRect;
+/**
+ * Measures the viewport-relative bounding box of an element (without scroll additions).
+ */
+export declare function measureAbsoluteRect(element: HTMLElement): LayoutRect;
+/**
+ * Compares two layout rectangles within an acceptable threshold tolerance (default 0.5px).
+ */
+export declare function areRectsEqual(a: LayoutRect | null | undefined, b: LayoutRect | null | undefined, tolerance?: number): boolean;
+/**
+ * Executes a batch read across multiple elements in a single cycle, preventing layout thrashing.
+ */
+export declare function batchMeasure(elements: readonly HTMLElement[], includeScroll?: boolean): Map<HTMLElement, LayoutRect>;

package/dist/core/layout/presets.d.ts

@@ -0,0 +1,24 @@
+/**
+ * AF Motion Layout Transition Presets
+ */
+import type { LayoutPreset, LayoutTransitionOptions } from "./types.js";
+export interface ResolvedLayoutConfig {
+    readonly duration: number;
+    readonly easing: string;
+    readonly mode: "position" | "size" | "both" | "scale" | "fade-through" | "none";
+    readonly transformOrigin: string;
+    readonly respectReducedMotion: boolean;
+    readonly crossAxis: boolean;
+}
+export declare const LAYOUT_PRESETS: Readonly<Record<LayoutPreset, {
+    duration: number;
+    easing: string;
+}>>;
+/**
+ * Normalizes duration (seconds vs milliseconds).
+ */
+export declare function normalizeDuration(val?: number, fallback?: number): number;
+/**
+ * Resolves full layout transition parameters combining presets and custom options.
+ */
+export declare function resolveLayoutConfig(options?: LayoutTransitionOptions): ResolvedLayoutConfig;

package/dist/core/layout/types.d.ts

@@ -0,0 +1,189 @@
+/**
+ * AF Motion Automatic Layout Animation Engine Contracts
+ *
+ * Framework-independent contracts for automatic layout detection,
+ * First-Last-Invert-Play (FLIP) pipeline, layout groups, and coordinated transitions.
+ */
+import type { AnimationControls } from "../animation.js";
+import type { EasingOption } from "../../easing/easings.js";
+export declare const LAYOUT_SPEC_VERSION = "1.0.0";
+/**
+ * Geometric bounding box representation for layout calculations.
+ */
+export interface LayoutRect {
+    readonly top: number;
+    readonly left: number;
+    readonly width: number;
+    readonly height: number;
+    readonly right: number;
+    readonly bottom: number;
+    readonly scrollX?: number;
+    readonly scrollY?: number;
+}
+/**
+ * Delta values between First and Last layout states.
+ */
+export interface LayoutDelta {
+    readonly deltaX: number;
+    readonly deltaY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly hasMoved: boolean;
+    readonly hasResized: boolean;
+    readonly first: LayoutRect;
+    readonly last: LayoutRect;
+}
+/**
+ * Animation modes for layout transitions.
+ */
+export type LayoutAnimationMode = "position" | "size" | "both" | "scale" | "fade-through" | "none";
+/**
+ * Built-in layout transition presets.
+ */
+export type LayoutPreset = "gentle" | "snappy" | "bouncy" | "smooth" | "subtle";
+/**
+ * Configurable options for an enter transition on newly inserted elements.
+ */
+export interface LayoutEnterAnimation {
+    readonly opacity?: number;
+    readonly scale?: number;
+    readonly duration?: number;
+    readonly easing?: EasingOption;
+}
+/**
+ * Configurable options for an exit transition on removed elements.
+ */
+export interface LayoutExitAnimation {
+    readonly opacity?: number;
+    readonly scale?: number;
+    readonly duration?: number;
+    readonly easing?: EasingOption;
+}
+/**
+ * Common configuration options for layout transitions.
+ */
+export interface LayoutTransitionOptions {
+    /** Duration in milliseconds or seconds (values <= 10 are treated as seconds). Defaults to 300ms. */
+    readonly duration?: number;
+    /** Easing curve or preset name. Defaults to "cubic-bezier(0.25, 1, 0.5, 1)". */
+    readonly easing?: EasingOption;
+    /** Layout animation mode: "position", "size", "both", "scale", "fade-through", or "none". Defaults to "both". */
+    readonly mode?: LayoutAnimationMode;
+    /** Named layout preset: "gentle", "snappy", "bouncy", "smooth", or "subtle". */
+    readonly preset?: LayoutPreset;
+    /** Delay before animation starts (ms or s). Defaults to 0. */
+    readonly delay?: number;
+    /** CSS transform-origin. Defaults to "top left" for accurate FLIP scaling. */
+    readonly transformOrigin?: string;
+    /** Whether to respect user's reduced-motion preference. Defaults to true. */
+    readonly respectReducedMotion?: boolean;
+    /** Whether to animate cross-axis transitions smoothly. Defaults to true. */
+    readonly crossAxis?: boolean;
+    /** Compensate for parent element scale transformations. Defaults to false. */
+    readonly compensateParentScale?: boolean;
+    /** Optional enter animation if element was just added to layout. */
+    readonly enterAnimation?: LayoutEnterAnimation;
+    /** Optional exit animation before element is removed. */
+    readonly exitAnimation?: LayoutExitAnimation;
+    /** Lifecycle callback when layout transition begins. */
+    readonly onStart?: (element: HTMLElement) => void;
+    /** Lifecycle callback during animation progress (0 to 1). */
+    readonly onUpdate?: (progress: number) => void;
+    /** Lifecycle callback when layout transition finishes. */
+    readonly onComplete?: (element: HTMLElement) => void;
+    /** Lifecycle callback when layout transition is cancelled or retargeted. */
+    readonly onCancel?: (element: HTMLElement) => void;
+}
+/**
+ * Options for configuring a single layout controller.
+ */
+export interface LayoutControllerOptions extends LayoutTransitionOptions {
+    /** Optional unique identifier for this element. */
+    readonly id?: string;
+    /** Whether to automatically observe resize and mutations using ResizeObserver / MutationObserver. Defaults to true. */
+    readonly autoObserve?: boolean;
+    /** Whether to observe parent container child mutations. Defaults to true. */
+    readonly observeParent?: boolean;
+    /** Debounce/batch delay in milliseconds for layout observation. Defaults to 0 (RAF batched). */
+    readonly batchWaitMs?: number;
+    /** Event callback fired whenever a layout change is detected. */
+    readonly onLayoutChange?: (change: LayoutChangeEvent) => void;
+}
+/**
+ * Detailed information about a detected layout change.
+ */
+export interface LayoutChangeEvent {
+    readonly element: HTMLElement;
+    readonly previousRect: LayoutRect;
+    readonly currentRect: LayoutRect;
+    readonly deltaX: number;
+    readonly deltaY: number;
+    readonly scaleX: number;
+    readonly scaleY: number;
+    readonly hasMoved: boolean;
+    readonly hasResized: boolean;
+}
+/**
+ * Current runtime state of a layout controller.
+ */
+export interface LayoutControllerState {
+    readonly id: string;
+    readonly isAnimating: boolean;
+    readonly isObserved: boolean;
+    readonly bounds: LayoutRect | null;
+    readonly lastDelta: LayoutDelta | null;
+    readonly currentProgress: number;
+}
+/**
+ * Primary interface for controlling automatic layout animations on a DOM element.
+ */
+export interface LayoutController {
+    readonly id: string;
+    readonly element: HTMLElement;
+    getState(): LayoutControllerState;
+    getBounds(): LayoutRect | null;
+    isAnimating(): boolean;
+    measure(): LayoutRect;
+    record(): LayoutRect;
+    animate(options?: Partial<LayoutTransitionOptions>): AnimationControls | null;
+    retarget(newTargetRect?: LayoutRect): void;
+    updateOptions(options: Partial<LayoutControllerOptions>): void;
+    play(): void;
+    pause(): void;
+    cancel(): void;
+    finish(): void;
+    destroy(): void;
+}
+/**
+ * Staggering sequence direction across layout group members.
+ */
+export type LayoutStaggerDirection = "forward" | "reverse" | "center" | "random";
+/**
+ * Options for coordinating a group of layout-animated elements.
+ */
+export interface LayoutGroupOptions extends LayoutTransitionOptions {
+    /** Optional group ID. */
+    readonly id?: string;
+    /** Stagger delay between items in milliseconds (or seconds). */
+    readonly stagger?: number;
+    /** Staggering order direction. Defaults to "forward". */
+    readonly staggerDirection?: LayoutStaggerDirection;
+    /** Whether to synchronize animation durations across all members. Defaults to false. */
+    readonly coordinated?: boolean;
+}
+/**
+ * Group controller for coordinating multi-element layout transitions.
+ */
+export interface LayoutGroup {
+    readonly id: string;
+    add(element: HTMLElement | LayoutController, options?: Partial<LayoutControllerOptions>): LayoutController;
+    remove(elementOrId: HTMLElement | string): void;
+    get(elementOrId: HTMLElement | string): LayoutController | undefined;
+    getAll(): readonly LayoutController[];
+    measureAll(): Map<string, LayoutRect>;
+    recordAll(): void;
+    animateAll(options?: Partial<LayoutGroupOptions>): readonly AnimationControls[];
+    updateOptions(options: Partial<LayoutGroupOptions>): void;
+    cancelAll(): void;
+    destroy(): void;
+}

package/dist/core/microinteractions/generator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AF Motion Microinteraction Plan Generator
+ *
+ * Deterministic generation of context-aware microinteraction specifications,
+ * animation timing, easing, spring curves, accessibility fallbacks, and alternatives.
+ */
+import type { MicrointeractionContext, MicrointeractionResult } from "./types.js";
+/**
+ * Generates an intelligent, deterministic microinteraction plan.
+ */
+export declare function generateMicrointeractionPlan(context: MicrointeractionContext): MicrointeractionResult;

package/dist/core/microinteractions/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AF Motion Intelligent Microinteractions Module
+ *
+ * Microinteraction plan generation, intent classification, runtime controller,
+ * state machine, and AI registry discovery.
+ */
+export * from "./types.js";
+export * from "./intent.js";
+export * from "./generator.js";
+export * from "./runtime.js";
+export * from "./schema.js";

package/dist/core/microinteractions/intent.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AF Motion Microinteraction Intent Classification
+ *
+ * Deterministic natural-language interpretation and keyword classification
+ * for component categories, interaction states, and feedback archetypes.
+ */
+import type { ClassifiedMicrointeractionIntent, MicrointeractionContext } from "./types.js";
+/**
+ * Classifies microinteraction intent from a context or natural-language query.
+ */
+export declare function classifyMicrointeractionIntent(input: MicrointeractionContext | string): ClassifiedMicrointeractionIntent;

package/dist/core/microinteractions/runtime.d.ts

@@ -0,0 +1,25 @@
+/**
+ * AF Motion Microinteraction Runtime Controller
+ *
+ * Framework-independent controller managing interaction states, DOM event listeners,
+ * animation transitions, cancellation, and clean resource disposal.
+ */
+import type { InteractionState, MicrointeractionContext, MicrointeractionPlan, MicrointeractionRuntimeControls } from "./types.js";
+export interface MicrointeractionRuntimeOptions extends MicrointeractionContext {
+    readonly onStateChange?: (state: InteractionState, plan: MicrointeractionPlan) => void;
+}
+export declare class MicrointeractionController implements MicrointeractionRuntimeControls {
+    private element;
+    private currentState;
+    private activeAnimation;
+    private options;
+    private boundListeners;
+    constructor(options?: MicrointeractionRuntimeOptions);
+    getState(): InteractionState;
+    setState(nextState: InteractionState): void;
+    attach(element: HTMLElement): void;
+    detach(): void;
+    destroy(): void;
+    private runAnimation;
+}
+export declare function createMicrointeractionController(options?: MicrointeractionRuntimeOptions): MicrointeractionController;

package/dist/core/microinteractions/schema.d.ts

@@ -0,0 +1,82 @@
+/**
+ * AF Motion Microinteraction Schema & AI Motion Registry Integration
+ *
+ * Machine-readable capability definitions and discovery helpers for
+ * intelligent microinteraction generation and runtime control.
+ */
+import { type InteractionState, type MicroComponentCategory, type MicrointeractionFeedbackType, type MicrointeractionTrigger } from "./types.js";
+export declare const MICROINTERACTION_CAPABILITY: {
+    id: string;
+    name: string;
+    category: "interactive";
+    description: string;
+    tags: string[];
+    version: string;
+    features: string[];
+    supportedCategories: readonly MicroComponentCategory[];
+    supportedStates: readonly InteractionState[];
+    supportedTriggers: readonly MicrointeractionTrigger[];
+    supportedFeedbackTypes: readonly MicrointeractionFeedbackType[];
+    parameters: {
+        name: string;
+        kind: "positional";
+        type: string;
+        required: boolean;
+        description: string;
+    }[];
+    supportedTargets: string[];
+    signature: {
+        importStatement: string;
+        invocation: string;
+        exampleCode: string;
+    };
+    controls: string[];
+    callbacks: string[];
+    reducedMotion: "static-fallback";
+    compatibility: {
+        browser: boolean;
+        ssr: boolean;
+        requiresCanvas: boolean;
+    };
+};
+export declare function getMicrointeractionCapability(): {
+    id: string;
+    name: string;
+    category: "interactive";
+    description: string;
+    tags: string[];
+    version: string;
+    features: string[];
+    supportedCategories: readonly MicroComponentCategory[];
+    supportedStates: readonly InteractionState[];
+    supportedTriggers: readonly MicrointeractionTrigger[];
+    supportedFeedbackTypes: readonly MicrointeractionFeedbackType[];
+    parameters: {
+        name: string;
+        kind: "positional";
+        type: string;
+        required: boolean;
+        description: string;
+    }[];
+    supportedTargets: string[];
+    signature: {
+        importStatement: string;
+        invocation: string;
+        exampleCode: string;
+    };
+    controls: string[];
+    callbacks: string[];
+    reducedMotion: "static-fallback";
+    compatibility: {
+        browser: boolean;
+        ssr: boolean;
+        requiresCanvas: boolean;
+    };
+};
+export declare function listSupportedMicroComponentCategories(): readonly MicroComponentCategory[];
+export declare function listSupportedInteractionStates(): readonly InteractionState[];
+export declare function listSupportedMicrointeractionTriggers(): readonly MicrointeractionTrigger[];
+export declare function listSupportedMicrointeractionFeedbackTypes(): readonly MicrointeractionFeedbackType[];
+export declare function registerMicrointeractionCapability(registry: {
+    registerCapability: (cap: any, opts?: any) => void;
+}): void;

package/dist/core/microinteractions/types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * AF Motion Intelligent Microinteraction Contracts
+ *
+ * Framework-independent contracts for context-aware microinteraction generation,
+ * component categories, interaction states, triggers, feedback patterns, and runtime controllers.
+ */
+import type { AnimatableProperties } from "../animate.js";
+export declare const MICROINTERACTION_VERSION = "1.0.0";
+export type MicroComponentCategory = "button" | "icon-button" | "card" | "surface" | "input" | "text-field" | "checkbox" | "radio" | "toggle" | "dropdown" | "menu" | "tooltip" | "tabs" | "accordion" | "disclosure" | "nav-item" | "link" | "dialog" | "modal" | "toast" | "notification" | "slider" | "media-control" | "custom";
+export declare const MICRO_COMPONENT_CATEGORIES: readonly MicroComponentCategory[];
+export type InteractionState = "idle" | "hover" | "focus" | "focus-visible" | "press" | "release" | "active" | "selected" | "disabled" | "loading" | "success" | "error" | "expanded" | "collapsed" | "dragging" | "dropping";
+export declare const INTERACTION_STATES: readonly InteractionState[];
+export type MicrointeractionTrigger = "pointer" | "keyboard" | "focus" | "toggle" | "drag" | "state-change" | "programmatic";
+export declare const MICROINTERACTION_TRIGGERS: readonly MicrointeractionTrigger[];
+export type MicrointeractionFeedbackType = "scale-press" | "hover-lift" | "focus-ring" | "ripple" | "glow-pulse" | "shake-error" | "pop-success" | "toggle-slide" | "disclosure-expand" | "drag-elevation" | "subtle-color";
+export declare const MICROINTERACTION_FEEDBACK_TYPES: readonly MicrointeractionFeedbackType[];
+export interface MicrointeractionConfig {
+    readonly properties: Readonly<AnimatableProperties>;
+    readonly duration: number;
+    readonly delay?: number;
+    readonly easing?: string;
+    readonly spring?: {
+        readonly stiffness?: number;
+        readonly damping?: number;
+        readonly mass?: number;
+    };
+    readonly transformOrigin?: string;
+    readonly hapticFeedback?: boolean;
+    readonly ariaLive?: "polite" | "assertive" | "off";
+    readonly materialEffect?: "glass" | "metallic" | "shadow" | "glow" | "none";
+}
+export interface MicrointeractionPlan {
+    readonly id: string;
+    readonly name: string;
+    readonly category: MicroComponentCategory;
+    readonly trigger: MicrointeractionTrigger;
+    readonly fromState: InteractionState;
+    readonly toState: InteractionState;
+    readonly feedbackType: MicrointeractionFeedbackType;
+    readonly config: MicrointeractionConfig;
+    readonly reducedMotionConfig: MicrointeractionConfig;
+    readonly compatibilityScore: number;
+    readonly explanation: string;
+    readonly respectReducedMotion: boolean;
+}
+export interface MicrointeractionContext {
+    readonly category?: MicroComponentCategory;
+    readonly intent?: string;
+    readonly trigger?: MicrointeractionTrigger;
+    readonly fromState?: InteractionState;
+    readonly toState?: InteractionState;
+    readonly visualStyle?: string;
+    readonly motionDNA?: string;
+    readonly reducedMotion?: boolean;
+    readonly deviceTier?: "low" | "medium" | "high";
+    readonly disabled?: boolean;
+}
+export interface MicrointeractionResult {
+    readonly plan: MicrointeractionPlan;
+    readonly alternatives: readonly MicrointeractionPlan[];
+    readonly compatibilityScore: number;
+    readonly warnings: readonly string[];
+    readonly explanation: string;
+    readonly context: MicrointeractionContext;
+}
+export interface ClassifiedMicrointeractionIntent {
+    readonly category: MicroComponentCategory;
+    readonly targetState: InteractionState;
+    readonly feedbackType: MicrointeractionFeedbackType;
+    readonly confidence: number;
+    readonly matchedKeywords: readonly string[];
+}
+export interface MicrointeractionRuntimeControls {
+    readonly getState: () => InteractionState;
+    readonly setState: (state: InteractionState) => void;
+    readonly attach: (element: HTMLElement) => void;
+    readonly detach: () => void;
+    readonly destroy: () => void;
+}