import { P as PinStorage, a as Pin, b as PinStatus, F as FrameworkInfo, E as ElementContext, c as ElementInfo, d as FrameworkAdapter, C as ComponentInfo, S as SourceLocation, O as OutputFormat, A as AgentOutput, Q as QueuedAnnotation, e as PluginHooks, f as Plugin, g as PinpointAPI, h as PinpointConfig } from './index-Ct90phHd.js';
export { i as ContextMenuAction, j as CopyContext, D as DrawStroke, k as DrawToolType, l as PinEvent, T as TextNote, m as ToolbarMode } from './index-Ct90phHd.js';
import { z } from 'zod';

declare class MemoryStore implements PinStorage {
    private pins;
    load(pageUrl: string): Promise<Pin[]>;
    save(pin: Pin): Promise<void>;
    update(id: string, patch: Partial<Pin>): Promise<void>;
    delete(id: string): Promise<void>;
    list(filter?: {
        pageUrl?: string;
        status?: PinStatus;
    }): Promise<Pin[]>;
    clear(pageUrl?: string): Promise<void>;
}

declare class RestClient implements PinStorage {
    private endpoint;
    constructor(endpoint: string);
    load(pageUrl: string): Promise<Pin[]>;
    save(pin: Pin): Promise<void>;
    update(id: string, patch: Partial<Pin>): Promise<void>;
    delete(id: string): Promise<void>;
    list(filter?: {
        pageUrl?: string;
        status?: PinStatus;
    }): Promise<Pin[]>;
    clear(pageUrl?: string): Promise<void>;
}

declare const ElementInfoSchema: z.ZodObject<{
    tagName: z.ZodString;
    id: z.ZodOptional<z.ZodString>;
    classNames: z.ZodArray<z.ZodString>;
    selector: z.ZodString;
    textContent: z.ZodOptional<z.ZodString>;
    boundingRect: z.ZodObject<{
        x: z.ZodNumber;
        y: z.ZodNumber;
        width: z.ZodNumber;
        height: z.ZodNumber;
    }, z.core.$strip>;
    computedStyles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    ariaAttributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    dataAttributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    domPath: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const FrameworkInfoSchema: z.ZodObject<{
    framework: z.ZodString;
    componentPath: z.ZodString;
    sourceFile: z.ZodOptional<z.ZodString>;
    frameworkVersion: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
declare const PinSchema: z.ZodObject<{
    id: z.ZodString;
    pageUrl: z.ZodString;
    createdAt: z.ZodString;
    updatedAt: z.ZodString;
    author: z.ZodOptional<z.ZodString>;
    comment: z.ZodString;
    element: z.ZodObject<{
        tagName: z.ZodString;
        id: z.ZodOptional<z.ZodString>;
        classNames: z.ZodArray<z.ZodString>;
        selector: z.ZodString;
        textContent: z.ZodOptional<z.ZodString>;
        boundingRect: z.ZodObject<{
            x: z.ZodNumber;
            y: z.ZodNumber;
            width: z.ZodNumber;
            height: z.ZodNumber;
        }, z.core.$strip>;
        computedStyles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        ariaAttributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        dataAttributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
        domPath: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
    framework: z.ZodOptional<z.ZodObject<{
        framework: z.ZodString;
        componentPath: z.ZodString;
        sourceFile: z.ZodOptional<z.ZodString>;
        frameworkVersion: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    status: z.ZodObject<{
        state: z.ZodEnum<{
            open: "open";
            acknowledged: "acknowledged";
            resolved: "resolved";
            dismissed: "dismissed";
        }>;
        changedAt: z.ZodString;
        changedBy: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
}, z.core.$strip>;

interface ElementPickerOptions {
    onHover?: (element: Element | null, rect: DOMRect | null) => void;
    onStableHover?: (element: Element) => void;
    onSelect?: (element: Element) => void;
    ignoreSelector?: string;
    blockInteractions?: boolean;
}
declare class ElementPicker {
    private active;
    private paused;
    private hoveredElement;
    private rafId;
    private stableTimeout;
    private lastTarget;
    private options;
    private handleMouseMove;
    private handleClick;
    private handleKeyDown;
    constructor(options?: ElementPickerOptions);
    private isOwnUI;
    private shouldIgnore;
    private pierceElementFromPoint;
    private processHover;
    private clearStableTimeout;
    activate(): void;
    deactivate(): void;
    setBlockInteractions(value: boolean): void;
    pause(): void;
    resume(): void;
    isPaused(): boolean;
    isActive(): boolean;
    getHoveredElement(): Element | null;
    dispose(): void;
}

interface SelectorOptions {
    timeoutMs?: number;
    skipClassPatterns?: RegExp[];
}
declare function buildSelector(element: Element, options?: SelectorOptions): string;

declare function extractElementInfo(element: Element): ElementInfo;
declare function buildElementContext(element: Element, frameworkInfo?: FrameworkInfo): ElementContext;

interface DragSelectOptions {
    coverageThreshold?: number;
    onDragStart?: (rect: DOMRect) => void;
    onDragMove?: (rect: DOMRect) => void;
    onDragEnd?: (elements: Element[]) => void;
    ignoreSelector?: string;
}
declare class DragSelect {
    private active;
    private dragging;
    private startX;
    private startY;
    private options;
    private handleMouseDown;
    private handleMouseMove;
    private handleMouseUp;
    constructor(options?: DragSelectOptions);
    private buildRect;
    private getElementsInRect;
    activate(): void;
    deactivate(): void;
    isDragging(): boolean;
    dispose(): void;
}

interface TextSelection {
    text: string;
    container: Element;
    startOffset: number;
    endOffset: number;
    context: string;
    rect: DOMRect;
}
interface TextSelectOptions {
    onSelect?: (selection: TextSelection | null) => void;
    minLength?: number;
}
declare class TextSelect {
    private active;
    private options;
    private handleSelectionChange;
    private debounceTimer;
    constructor(options?: TextSelectOptions);
    private getTextSelection;
    activate(): void;
    deactivate(): void;
    getCurrentSelection(): TextSelection | null;
    dispose(): void;
}

declare function registerAdapter(adapter: FrameworkAdapter): void;
declare function detectFramework(): FrameworkAdapter;
declare function getComponentInfo(element: Element): ComponentInfo | null;
declare function getSourceLocation(element: Element): SourceLocation | null;

declare const reactAdapter: FrameworkAdapter;

declare const vueAdapter: FrameworkAdapter;

declare const genericAdapter: FrameworkAdapter;

declare function formatPins(pins: Pin[], format?: OutputFormat): string;

declare function formatRichPinContext(pin: Pin): string;
declare function formatPinsForAgent(pins: Pin[], format?: OutputFormat): AgentOutput;
declare function formatQueueForAgent(queue: QueuedAnnotation[], format?: OutputFormat): AgentOutput;

declare function registerPlugin(plugin: Plugin, api?: PinpointAPI): void;
declare function unregisterPlugin(name: string): void;
declare function getPlugins(): string[];
declare function dispatchHook(name: keyof PluginHooks, ...args: unknown[]): void;

declare const agentNativePlugin: Plugin;

interface FreezeOptions {
    jsTimers?: boolean;
}
declare function freeze(_elements?: Element[], options?: FreezeOptions): void;
declare function unfreeze(): void;
declare function isFreezeActive(): boolean;

declare function escapeHtml(str: string): string;
declare function sanitizeString(str: string, maxLength?: number): string;

/**
 * Validate that a message origin is allowed.
 * Used for postMessage security when communicating with frames.
 */
declare function isAllowedOrigin(origin: string, allowedOrigins?: string[]): boolean;

/**
 * Open a file in the user's editor. Tries vscode:// protocol first,
 * falls back to a fetch to /api/open-file.
 */
declare function openFile(filePath: string, lineNumber?: number): Promise<void>;

interface MountResult {
    dispose: () => void;
    shadowRoot: ShadowRoot;
    container: HTMLDivElement;
}
declare function mountPinpoint(config?: PinpointConfig, target?: HTMLElement): MountResult;
declare function unmountPinpoint(): void;

declare class PinMarkerManager {
    private markerColor;
    private markers;
    private updateTimer;
    private onClick;
    private onToggleSelect;
    private selectedPinIds;
    private showCheckboxes;
    constructor(markerColor?: string);
    setOnClick(handler: (pin: Pin) => void): void;
    setOnToggleSelect(handler: (pin: Pin) => void): void;
    setSelectedPins(ids: Set<string>): void;
    setShowCheckboxes(show: boolean): void;
    update(pins: Pin[]): void;
    private updateCheckboxVisual;
    private updateMarker;
    startTracking(pins: Pin[]): void;
    stopTracking(): void;
    dispose(): void;
}

export { AgentOutput, ComponentInfo, DragSelect, ElementContext, ElementInfo, ElementInfoSchema, ElementPicker, FrameworkAdapter, FrameworkInfo, FrameworkInfoSchema, MemoryStore, OutputFormat, Pin, PinMarkerManager, PinSchema, PinStatus, PinStorage, PinpointAPI, PinpointConfig, Plugin, PluginHooks, QueuedAnnotation, RestClient, SourceLocation, TextSelect, agentNativePlugin, buildElementContext, buildSelector, detectFramework, dispatchHook, escapeHtml, extractElementInfo, formatPins, formatPinsForAgent, formatQueueForAgent, formatRichPinContext, freeze, genericAdapter, getComponentInfo, getPlugins, getSourceLocation, isAllowedOrigin, isFreezeActive, mountPinpoint, openFile, reactAdapter, registerAdapter, registerPlugin, sanitizeString, unfreeze, unmountPinpoint, unregisterPlugin, vueAdapter };