declare const STICKER_COLOR_NAMES: readonly ["slate", "gray", "zinc", "neutral", "stone", "red", "orange", "amber", "yellow", "lime", "green", "emerald", "teal", "cyan", "sky", "blue", "indigo", "violet", "purple", "fuchsia", "pink", "rose"];
type StickerColorName = (typeof STICKER_COLOR_NAMES)[number];
declare const STICKER_COLOR_STEPS: readonly [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950];
type StickerColorStep = (typeof STICKER_COLOR_STEPS)[number];

declare const STICKER_FAMILIES: readonly ["padding", "margin", "border", "radius", "stack", "grid", "text", "color", "transform", "opacity"];
type StickerFamily = (typeof STICKER_FAMILIES)[number];
declare const SPACING_STEPS: readonly [0, 1, 2, 3, 4, 6, 8, 10, 12, 16];
declare const TRANSLATE_STEPS: readonly [-16, -12, -10, -8, -6, -4, -3, -2, -1, 0, 1, 2, 3, 4, 6, 8, 10, 12, 16];
declare const BORDER_STEPS: readonly [0, 1, 2, 4, 8];
declare const DIRECTION_STEPS: readonly ["vertical", "horizontal"];
declare const ALIGN_STEPS: readonly ["stretch", "start", "center", "end", "baseline"];
declare const JUSTIFY_STEPS: readonly ["start", "center", "end", "between", "around", "evenly"];
declare const GRID_COUNT_STEPS: readonly [1, 2, 3, 4, 5, 6];
declare const FONT_SIZE_STEPS: readonly ["xs", "sm", "base", "lg", "xl", "2xl", "3xl", "4xl"];
declare const FONT_WEIGHT_STEPS: readonly [300, 400, 500, 600, 700, 800];
declare const LINE_HEIGHT_STEPS: readonly ["none", "tight", "snug", "normal", "relaxed", "loose"];
declare const LETTER_SPACING_STEPS: readonly ["tighter", "tight", "normal", "wide", "wider", "widest"];
declare const TEXT_ALIGN_STEPS: readonly ["left", "center", "right", "justify"];
declare const SCALE_STEPS: readonly [25, 50, 75, 90, 95, 100, 105, 110, 125, 150];
declare const ROTATE_STEPS: readonly [-180, -90, -45, -25, -12, -6, -3, -2, -1, 0, 1, 2, 3, 6, 12, 25, 45, 90, 180];
declare const OPACITY_STEPS: readonly [0, 5, 10, 20, 25, 30, 40, 50, 60, 70, 75, 80, 90, 95, 100];
declare const MIX_BLEND_STEPS: readonly ["normal", "multiply", "screen", "overlay", "darken", "lighten", "color-dodge", "color-burn", "hard-light", "soft-light", "difference", "exclusion", "hue", "saturation", "color", "luminosity"];
type StickerStep = (typeof SPACING_STEPS)[number] | (typeof BORDER_STEPS)[number] | (typeof DIRECTION_STEPS)[number] | (typeof ALIGN_STEPS)[number] | (typeof JUSTIFY_STEPS)[number] | (typeof GRID_COUNT_STEPS)[number] | (typeof FONT_SIZE_STEPS)[number] | (typeof FONT_WEIGHT_STEPS)[number] | (typeof LINE_HEIGHT_STEPS)[number] | (typeof LETTER_SPACING_STEPS)[number] | (typeof TEXT_ALIGN_STEPS)[number] | (typeof TRANSLATE_STEPS)[number] | (typeof SCALE_STEPS)[number] | (typeof ROTATE_STEPS)[number] | (typeof OPACITY_STEPS)[number] | (typeof MIX_BLEND_STEPS)[number] | StickerColorStep;
type StickerSubproperty = 'all' | 'x' | 'y' | 'top' | 'right' | 'bottom' | 'left' | 'top-left' | 'top-right' | 'bottom-right' | 'bottom-left' | 'vertical' | 'horizontal' | 'direction' | 'gap' | 'align' | 'justify' | 'rows' | 'columns' | 'size' | 'weight' | 'line-height' | 'letter-spacing' | 'text-align' | 'color' | 'translate' | 'scale' | 'rotate' | 'opacity' | 'mix-blend' | StickerColorName;

type TargetFingerprint = {
    tag: string;
    attributes?: Record<string, string>;
    heading?: string;
    text?: string;
};

type AnnotationLifecycleStatus = 'pending' | 'sending' | 'awaiting_review' | 'in_flight' | 'resolved' | 'needs_review' | 'dismissed' | 'waiting_input' | 'failed';
type ScopeBreadth = 'instance' | 'pattern';
type ScopeTarget = 'element' | 'component' | 'token';
type Scope = {
    breadth: ScopeBreadth;
    target: ScopeTarget;
};
declare const TOOL_TYPES: readonly ["inspector", "sticker", "model"];
type ToolType = (typeof TOOL_TYPES)[number];
declare const LEGACY_ANNOTATION_TYPES: readonly ["freehand", "line", "rectangle", "circle"];
type LegacyAnnotationType = (typeof LEGACY_ANNOTATION_TYPES)[number];
type AnnotationType = LegacyAnnotationType | 'text';
type Point = {
    x: number;
    y: number;
};
type AnnotationRevealStep = {
    triggerSelector: string;
    targetSelector?: string;
    label: string;
};
type AnnotationRevealRecipe = {
    steps: AnnotationRevealStep[];
    location: string[];
};
type ReactSourceLocation = {
    fileName: string;
    lineNumber: number;
    columnNumber?: number;
};
/** Coordinates refer to the original image, not its responsive DOM rectangle. */
type ImageObjectContext = {
    src: string;
    alt: string;
    width: number;
    height: number;
    box: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    normalizedBox: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
};
/** Coordinates refer to the decoded video frame, not its responsive DOM box. */
type VideoObjectContext = {
    src: string;
    width: number;
    height: number;
    duration: number;
    currentTime: number;
    normalizedBox: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    box: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    trackStart: number;
    trackEnd: number;
};
type SubjectFeedbackAttachment = {
    /** Zero-based index in this annotation's transported images. */
    cropImageIndex?: number;
    warning?: string;
};
type ElementInfo = {
    targetFingerprint?: TargetFingerprint;
    selector: string;
    tagName: string;
    /** Adapter-owned semantic name for a non-DOM subject. */
    subjectLabel?: string;
    id?: string;
    className?: string;
    textContent?: string;
    dataAttributes?: Record<string, string>;
    reactComponent?: string;
    reactComponentPath?: string[];
    reactSource?: ReactSourceLocation;
    imageObject?: ImageObjectContext;
    videoObject?: VideoObjectContext;
    /** The real DOM surface, rather than the subject's hidden projection. */
    sourceElement?: ElementInfo;
    context?: string;
    revealRecipe?: AnnotationRevealRecipe;
};
/** Renderer-owned identity for a target that does not exist as a DOM node. */
type OpaqueTargetReference = {
    adapter: string;
    key: string;
};
type StyleChange = {
    property: string;
    original: string;
    modified: string;
    token?: string;
    sticker?: {
        family: StickerFamily;
        subproperty: StickerSubproperty;
        step: StickerStep;
        axisSteps?: {
            x: StickerStep;
            y: StickerStep;
        };
    };
};
type StyleModification = {
    /** Receipt-derived presentation only; never written to the editable draft. */
    awaitingReview?: {
        submissionId: string;
        threadId: string;
    };
    selector: string;
    durableSelector?: string;
    element: ElementInfo;
    changes: StyleChange[];
    createdAt?: number;
    annotationNumber?: number;
    captured?: boolean;
    pathname?: string;
};
type TextModification = {
    selector: string;
    durableSelector?: string;
    element: ElementInfo;
    textNodePath: number[];
    original: string;
    modified: string;
    createdAt?: number;
    annotationNumber?: number;
    captured?: boolean;
    pathname?: string;
};
type DomInsertionPlacement = 'before' | 'after';
type DomModification = {
    id: string;
    operation: 'move' | 'copy';
    selector: string;
    durableSelector?: string;
    element: ElementInfo;
    sourceSelector?: string;
    sourceDurableSelector?: string;
    sourceElement?: ElementInfo;
    originalParentSelector?: string;
    originalParentDurableSelector?: string;
    originalIndex?: number;
    targetParentSelector: string;
    targetParentDurableSelector?: string;
    targetIndex: number;
    referenceSelector?: string;
    referenceDurableSelector?: string;
    placement: DomInsertionPlacement;
    captured?: boolean;
    pathname?: string;
};
type SpacingElementEvidence = {
    selector: string;
    reactComponent?: string;
    className: string;
    property: string;
    matchedClass?: string;
    suggestedClass?: string;
};
type SpacingTokenChange = {
    id: string;
    tokenPath: string;
    tokenName: string;
    originalPx: number;
    newPx: number;
    captured?: boolean;
    affectedElements: SpacingElementEvidence[];
};
type AnnotationAttachment = {
    id: string;
    name: string;
    mimeType: string;
    size: number;
    kind: 'svg' | 'text';
};
type InteractionEpisodeElementState = {
    selector?: string;
    tagName: string;
    className?: string;
    role?: string;
    ariaLabel?: string;
    text?: string;
    value?: string;
    checked?: boolean;
    disabled?: boolean;
    expanded?: boolean;
    pressed?: boolean;
    selected?: boolean;
    rect?: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    subject?: {
        adapter: string;
        key: string;
        label: string;
        context?: string;
        data?: Record<string, string>;
    };
    media?: {
        kind: 'image';
        src?: string;
        complete: boolean;
        naturalWidth: number;
        naturalHeight: number;
    } | {
        kind: 'video';
        src?: string;
        currentTime: number;
        duration?: number;
        paused: boolean;
    } | {
        kind: 'canvas';
        width: number;
        height: number;
    };
};
type InteractionEpisodeChange = {
    kind: 'added' | 'removed' | 'updated';
    element: InteractionEpisodeElementState;
};
type InteractionEpisodeStep = {
    id: string;
    action: {
        kind: 'click' | 'drag' | 'input' | 'change' | 'submit' | 'keydown' | 'scroll' | 'play' | 'pause' | 'seek';
        label: string;
        key?: string;
        target?: InteractionEpisodeElementState;
    };
    startedAt: number;
    completedAt: number;
    outcome: 'changed' | 'no-observable-change';
    changes: InteractionEpisodeChange[];
    result?: InteractionEpisodeElementState;
    visuals?: {
        beforeFrameId?: string;
        afterFrameId?: string;
    };
};
type InteractionEpisodeFrame = {
    id: string;
    /** Index in the annotation's out-of-band image list. */
    imageIndex: number;
    fingerprint: string;
};
/** A compact, semantic account of actions performed while Comment passes through. */
type InteractionEpisode = {
    version: 1;
    startedAt: number;
    completedAt: number;
    subject?: InteractionEpisodeElementState;
    steps: InteractionEpisodeStep[];
    frames?: InteractionEpisodeFrame[];
};
type Annotation = {
    id: string;
    type: AnnotationType;
    points: Point[];
    color: string;
    strokeWidth: number;
    text?: string;
    fontSize?: number;
    timestamp: number;
    groupId?: string;
    captured?: boolean;
    status?: AnnotationLifecycleStatus;
    question?: string;
    resolutionSummary?: string;
    scope?: Scope | null;
    replyCount?: number;
    replyJobIds?: string[];
    threadId?: string;
    targetBindingId?: string;
    target?: OpaqueTargetReference;
    pathname?: string;
    elements?: ElementInfo[];
    linkedSelector?: string;
    linkedAnchor?: 'top-left' | 'bottom-left';
    imageCount?: number;
    attachments?: AnnotationAttachment[];
    interactionEpisode?: InteractionEpisode;
};
type BridgeStatus = {
    ok: boolean;
    activeJob: {
        id: string;
        status: string;
    } | null;
    queueDepth: number;
    sessionId: string | null;
};
type ClaudeResponse = {
    jobId: string;
    sessionId?: string;
    text: string;
    success: boolean;
    toolsUsed: string[];
};

type PopmeltSubjectBounds = {
    left: number;
    top: number;
    width: number;
    height: number;
};
type PopmeltSubjectTrackingAnchor = {
    /** Horizontal position normalized within the subject bounds. */
    x: number;
    /** Vertical position normalized within the subject bounds. */
    y: number;
};
type PopmeltSubjectOutlinePoint = {
    /** Horizontal position normalized within the subject bounds. */
    x: number;
    /** Vertical position normalized within the subject bounds. */
    y: number;
};
type PopmeltSubject = {
    key: string;
    label: string;
    bounds: PopmeltSubjectBounds;
    /** Viewport bounds of the renderer surface that owns this subject. */
    surfaceBounds?: PopmeltSubjectBounds;
    context?: string;
    data?: Record<string, string>;
    /** Live owning surface; never serialized or included in model context. */
    sourceElement?: Element;
    imageObject?: ImageObjectContext;
    videoObject?: VideoObjectContext;
    /** Optional provider-neutral foreground anchors used by motion tracking. */
    trackingAnchors?: readonly PopmeltSubjectTrackingAnchor[];
    /** Optional provider-neutral contour normalized within the subject bounds. */
    outline?: readonly PopmeltSubjectOutlinePoint[];
};
type PopmeltSurfaceSnapshot = {
    element: HTMLCanvasElement;
    dataUrl: string;
};
type PopmeltSubjectCreationSession = {
    key: string;
    update(clientPoint: {
        x: number;
        y: number;
    }): PopmeltSubject | null;
    commit(): PopmeltSubject | null;
    cancel(): void;
};
/**
 * Minimal renderer boundary for non-DOM subjects. The adapter owns hit testing,
 * durable keys, and viewport projection; Popmelt owns annotations and threads.
 */
type PopmeltSubjectAdapter = {
    id: string;
    /** Surface ownership; an explicit image adapter replaces Core's default. */
    surfaceKind?: 'image' | 'video';
    /** Resolve once the adapter's persisted subject index is available. */
    whenReady?(): Promise<void>;
    /** Notify Core when asynchronous perception changes hit-testable subjects. */
    subscribe?(listener: () => void): () => void;
    /** Ordered hit candidates, innermost/most-specific first. */
    hitTestAll?(clientPoint: {
        x: number;
        y: number;
    }): readonly PopmeltSubject[];
    hitTest(clientPoint: {
        x: number;
        y: number;
    }): PopmeltSubject | null;
    resolve(key: string): PopmeltSubject | null;
    /** Recreate a missing durable subject from annotation-captured context. */
    restoreSubject?(key: string, elementInfo: ElementInfo): PopmeltSubject | null;
    /** Optional clean subject crop, without Popmelt's overlay. */
    captureSubject?(key: string): Blob | null | Promise<Blob | null>;
    /** Optional bitmap capture for renderer surfaces that DOM cloning cannot read. */
    captureSurfaces?(): readonly PopmeltSurfaceSnapshot[] | Promise<readonly PopmeltSurfaceSnapshot[]>;
    /** Begin a context-aware subject-creation gesture at a viewport point. */
    beginCreate?(clientPoint: {
        x: number;
        y: number;
    }): PopmeltSubjectCreationSession | null;
    /** Rename a subject without changing its durable key. */
    renameSubject?(key: string, label: string): PopmeltSubject | null;
    /** Replace a subject's viewport bounds, projected back into adapter space. */
    updateSubjectBounds?(key: string, bounds: PopmeltSubjectBounds): PopmeltSubject | null;
    /** Replace optional foreground anchors normalized within subject bounds. */
    updateSubjectTrackingAnchors?(key: string, anchors: readonly PopmeltSubjectTrackingAnchor[]): PopmeltSubject | null;
    /** Promote a transient perception candidate into a durable subject. */
    promoteSubject?(key: string): PopmeltSubject | null;
    /** Remove a user-created subject or hide an adapter-owned subject. */
    removeSubject?(key: string): void;
};

export type { Annotation as A, BridgeStatus as B, ClaudeResponse as C, DomModification as D, ElementInfo as E, ImageObjectContext as I, OpaqueTargetReference as O, PopmeltSubjectAdapter as P, ReactSourceLocation as R, SubjectFeedbackAttachment as S, TextModification as T, VideoObjectContext as V, AnnotationAttachment as a, StyleModification as b, SpacingTokenChange as c, AnnotationType as d, Point as e, PopmeltSubject as f, PopmeltSubjectBounds as g, PopmeltSubjectCreationSession as h, PopmeltSubjectOutlinePoint as i, PopmeltSubjectTrackingAnchor as j, PopmeltSurfaceSnapshot as k, StyleChange as l, ToolType as m };