@seoengine.ai/next-llm-ready 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,850 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { NextRequest, NextResponse } from 'next/server';
+
+/**
+ * next-llm-ready - TypeScript Type Definitions
+ * Make your Next.js content AI-ready
+ */
+/**
+ * Content metadata for LLM-ready output
+ */
+interface LLMContent {
+    /** Page/post title */
+    title: string;
+    /** Main content (HTML or Markdown) */
+    content: string;
+    /** Short description/excerpt */
+    excerpt?: string;
+    /** Canonical URL */
+    url: string;
+    /** Publication date (ISO 8601) */
+    date?: string;
+    /** Last modified date (ISO 8601) */
+    modifiedDate?: string;
+    /** Author name */
+    author?: string;
+    /** Categories/sections */
+    categories?: string[];
+    /** Tags/keywords */
+    tags?: string[];
+    /** Custom prompt prefix for AI context */
+    promptPrefix?: string;
+    /** Featured image URL */
+    image?: string;
+    /** Reading time in minutes */
+    readingTime?: number;
+}
+/**
+ * Generated markdown output
+ */
+interface MarkdownOutput {
+    /** Raw markdown string */
+    markdown: string;
+    /** Word count */
+    wordCount: number;
+    /** Estimated reading time */
+    readingTime: number;
+    /** Extracted headings for TOC */
+    headings: TOCHeading[];
+}
+/**
+ * Position options for UI elements
+ */
+type ButtonPosition = 'floating' | 'inline' | 'next-to-heading' | 'below-heading';
+/**
+ * TOC position options
+ */
+type TOCPosition = 'left' | 'right' | 'inline-start' | 'inline-end';
+/**
+ * Heading levels to include in TOC
+ */
+type HeadingLevel = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+/**
+ * Copy action types for analytics
+ */
+type CopyAction = 'copy' | 'view' | 'download';
+/**
+ * CopyButton component props
+ */
+interface CopyButtonProps {
+    /** Content to copy (LLMContent object or markdown string) */
+    content: LLMContent | string;
+    /** Button text */
+    text?: string;
+    /** Show dropdown with additional options */
+    showDropdown?: boolean;
+    /** Button position */
+    position?: ButtonPosition;
+    /** Enable keyboard shortcut (Ctrl+Shift+C / Cmd+Shift+C) */
+    keyboardShortcut?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Toast message on copy */
+    toastMessage?: string;
+    /** Toast duration in ms */
+    toastDuration?: number;
+    /** Callback on successful copy */
+    onCopy?: (action: CopyAction) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+    /** Analytics tracking function */
+    onAnalytics?: (event: AnalyticsEvent) => void;
+    /** Custom styles */
+    style?: React.CSSProperties;
+    /** Disable the button */
+    disabled?: boolean;
+}
+/**
+ * CopyDropdown component props (split button with menu)
+ */
+interface CopyDropdownProps extends Omit<CopyButtonProps, 'showDropdown'> {
+    /** Dropdown menu items */
+    menuItems?: DropdownMenuItem[];
+}
+/**
+ * Dropdown menu item
+ */
+interface DropdownMenuItem {
+    /** Unique identifier */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Icon component */
+    icon?: React.ReactNode;
+    /** Action to perform */
+    action: CopyAction | (() => void);
+    /** Keyboard shortcut hint */
+    shortcut?: string;
+}
+/**
+ * TOC (Table of Contents) component props
+ */
+interface TOCProps {
+    /** Content to extract headings from (HTML string or ref to content element) */
+    content?: string;
+    /** Reference to content container element */
+    contentRef?: React.RefObject<HTMLElement>;
+    /** Manually provided headings */
+    headings?: TOCHeading[];
+    /** Position of TOC */
+    position?: TOCPosition;
+    /** Heading levels to include */
+    levels?: HeadingLevel[];
+    /** Title for TOC section */
+    title?: string;
+    /** Sticky behavior */
+    sticky?: boolean;
+    /** Sticky offset from top (px) */
+    stickyOffset?: number;
+    /** Custom class name */
+    className?: string;
+    /** Smooth scroll behavior */
+    smoothScroll?: boolean;
+    /** Highlight active heading */
+    highlightActive?: boolean;
+    /** Collapsible on mobile */
+    collapsible?: boolean;
+    /** Initially collapsed */
+    defaultCollapsed?: boolean;
+    /** Custom styles */
+    style?: React.CSSProperties;
+}
+/**
+ * Single TOC heading item
+ */
+interface TOCHeading {
+    /** Heading ID (for anchor links) */
+    id: string;
+    /** Heading text content */
+    text: string;
+    /** Heading level (1-6) */
+    level: number;
+    /** Child headings (for nested structure) */
+    children?: TOCHeading[];
+}
+/**
+ * LLMBadge component props (shows AI-ready indicator)
+ */
+interface LLMBadgeProps {
+    /** Badge text */
+    text?: string;
+    /** Show tooltip with info */
+    showTooltip?: boolean;
+    /** Tooltip content */
+    tooltipContent?: string;
+    /** Badge size */
+    size?: 'sm' | 'md' | 'lg';
+    /** Custom class name */
+    className?: string;
+}
+/**
+ * useLLMCopy hook options
+ */
+interface UseLLMCopyOptions {
+    /** Content to copy */
+    content: LLMContent | string;
+    /** Success callback */
+    onSuccess?: (action: CopyAction) => void;
+    /** Error callback */
+    onError?: (error: Error) => void;
+    /** Analytics callback */
+    onAnalytics?: (event: AnalyticsEvent) => void;
+}
+/**
+ * useLLMCopy hook return value
+ */
+interface UseLLMCopyReturn {
+    /** Copy to clipboard function */
+    copy: () => Promise<boolean>;
+    /** View markdown function (returns markdown string) */
+    view: () => string;
+    /** Download markdown function */
+    download: (filename?: string) => void;
+    /** Generated markdown */
+    markdown: string;
+    /** Copy in progress */
+    isCopying: boolean;
+    /** Last copy was successful */
+    isSuccess: boolean;
+    /** Last error */
+    error: Error | null;
+}
+/**
+ * useTOC hook options
+ */
+interface UseTOCOptions {
+    /** Content container ref */
+    contentRef: React.RefObject<HTMLElement>;
+    /** Heading levels to track */
+    levels?: HeadingLevel[];
+    /** Root margin for intersection observer */
+    rootMargin?: string;
+    /** Threshold for intersection observer */
+    threshold?: number | number[];
+}
+/**
+ * useTOC hook return value
+ */
+interface UseTOCReturn {
+    /** Extracted headings */
+    headings: TOCHeading[];
+    /** Currently active heading ID */
+    activeId: string | null;
+    /** Scroll to heading function */
+    scrollTo: (id: string) => void;
+}
+/**
+ * useAnalytics hook options
+ */
+interface UseAnalyticsOptions {
+    /** API endpoint for tracking */
+    endpoint?: string;
+    /** Include page URL */
+    includeUrl?: boolean;
+    /** Include timestamp */
+    includeTimestamp?: boolean;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * useAnalytics hook return value
+ */
+interface UseAnalyticsReturn {
+    /** Track an event */
+    track: (event: AnalyticsEvent) => Promise<void>;
+    /** Track copy action */
+    trackCopy: () => Promise<void>;
+    /** Track view action */
+    trackView: () => Promise<void>;
+    /** Track download action */
+    trackDownload: () => Promise<void>;
+}
+/**
+ * Analytics event
+ */
+interface AnalyticsEvent {
+    /** Event type */
+    action: CopyAction;
+    /** Page/content identifier */
+    contentId?: string;
+    /** Page URL */
+    url?: string;
+    /** Timestamp */
+    timestamp?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Analytics handler config
+ */
+interface AnalyticsConfig {
+    /** Enable analytics */
+    enabled?: boolean;
+    /** API endpoint */
+    endpoint?: string;
+    /** Storage type */
+    storage?: 'memory' | 'localStorage' | 'custom';
+    /** Custom storage adapter */
+    storageAdapter?: AnalyticsStorageAdapter;
+    /** Batch events before sending */
+    batchSize?: number;
+    /** Flush interval in ms */
+    flushInterval?: number;
+}
+/**
+ * Custom analytics storage adapter
+ */
+interface AnalyticsStorageAdapter {
+    /** Save event */
+    save: (event: AnalyticsEvent) => Promise<void>;
+    /** Get all events */
+    getAll: () => Promise<AnalyticsEvent[]>;
+    /** Clear events */
+    clear: () => Promise<void>;
+}
+/**
+ * LLMs.txt endpoint configuration
+ */
+interface LLMsTxtConfig {
+    /** Site name */
+    siteName: string;
+    /** Site description */
+    siteDescription?: string;
+    /** Site URL */
+    siteUrl: string;
+    /** Content items to include */
+    content: LLMsTxtItem[];
+    /** Custom header text */
+    headerText?: string;
+    /** Custom footer text */
+    footerText?: string;
+}
+/**
+ * Single item in LLMs.txt listing
+ */
+interface LLMsTxtItem {
+    /** Content title */
+    title: string;
+    /** Page URL */
+    url: string;
+    /** Content type (post, page, etc.) */
+    type?: string;
+    /** Publication date */
+    date?: string;
+    /** Short description */
+    description?: string;
+}
+/**
+ * Markdown API handler options
+ */
+interface MarkdownHandlerOptions {
+    /** Function to fetch content by slug/id */
+    getContent: (slug: string) => Promise<LLMContent | null>;
+    /** Cache control header value */
+    cacheControl?: string;
+    /** Enable CORS */
+    cors?: boolean;
+}
+/**
+ * Analytics API handler options
+ */
+interface AnalyticsHandlerOptions {
+    /** Storage adapter */
+    storage: AnalyticsStorageAdapter;
+    /** Rate limiting (requests per minute) */
+    rateLimit?: number;
+    /** Enable CORS */
+    cors?: boolean;
+}
+/**
+ * Global LLM Ready configuration
+ */
+interface LLMReadyConfig {
+    /** Default button position */
+    defaultPosition?: ButtonPosition;
+    /** Default TOC position */
+    defaultTOCPosition?: TOCPosition;
+    /** Enable keyboard shortcuts globally */
+    keyboardShortcuts?: boolean;
+    /** Default prompt prefix */
+    promptPrefix?: string;
+    /** Analytics configuration */
+    analytics?: AnalyticsConfig;
+    /** Custom theme variables */
+    theme?: ThemeConfig;
+}
+/**
+ * Theme configuration (CSS variables)
+ */
+interface ThemeConfig {
+    /** Primary color */
+    primaryColor?: string;
+    /** Primary hover color */
+    primaryHover?: string;
+    /** Text color */
+    textColor?: string;
+    /** Background color */
+    backgroundColor?: string;
+    /** Border color */
+    borderColor?: string;
+    /** Border radius */
+    borderRadius?: string;
+    /** Font family */
+    fontFamily?: string;
+    /** Shadow */
+    shadow?: string;
+}
+/**
+ * HTML to Markdown conversion options
+ */
+interface HTMLToMarkdownOptions {
+    /** Preserve line breaks */
+    preserveLineBreaks?: boolean;
+    /** Convert images to markdown */
+    convertImages?: boolean;
+    /** Convert links to markdown */
+    convertLinks?: boolean;
+    /** Strip scripts and styles */
+    stripScripts?: boolean;
+    /** Custom element handlers */
+    customHandlers?: Record<string, (element: Element) => string>;
+}
+/**
+ * Download options
+ */
+interface DownloadOptions {
+    /** Filename (without extension) */
+    filename?: string;
+    /** File extension */
+    extension?: 'md' | 'txt';
+    /** Include metadata header */
+    includeMetadata?: boolean;
+}
+
+/**
+ * Simple copy button component
+ *
+ * @example
+ * ```tsx
+ * <CopyButton
+ *   content={{
+ *     title: "My Article",
+ *     content: "<p>Article content...</p>",
+ *     url: "https://example.com/article",
+ *   }}
+ *   text="Copy for AI"
+ * />
+ * ```
+ */
+declare function CopyButton({ content, text, position, keyboardShortcut, className, toastMessage, toastDuration, onCopy, onError, onAnalytics, style, disabled, }: CopyButtonProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Split button with dropdown for copy/view/download actions
+ *
+ * @example
+ * ```tsx
+ * <CopyDropdown
+ *   content={{
+ *     title: "My Article",
+ *     content: "<p>Article content...</p>",
+ *     url: "https://example.com/article",
+ *   }}
+ *   text="Copy for AI"
+ * />
+ * ```
+ */
+declare function CopyDropdown({ content, text, menuItems, position, keyboardShortcut, className, toastMessage, toastDuration, onCopy, onError, onAnalytics, style, disabled, }: CopyDropdownProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Table of Contents component
+ *
+ * @example
+ * ```tsx
+ * function Article() {
+ *   const contentRef = useRef<HTMLDivElement>(null);
+ *
+ *   return (
+ *     <div className="article-layout">
+ *       <TOC
+ *         contentRef={contentRef}
+ *         position="right"
+ *         levels={['h2', 'h3']}
+ *         sticky
+ *       />
+ *       <article ref={contentRef}>
+ *         <h2 id="intro">Introduction</h2>
+ *         <p>Content...</p>
+ *       </article>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function TOC({ content, contentRef, headings: providedHeadings, position, levels, title, sticky, stickyOffset, className, smoothScroll, highlightActive, collapsible, defaultCollapsed, style, }: TOCProps): react_jsx_runtime.JSX.Element | null;
+/**
+ * Mobile TOC with slide-up panel
+ */
+declare function TOCMobile(props: TOCProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Badge showing content is LLM-ready
+ *
+ * @example
+ * ```tsx
+ * <LLMBadge
+ *   text="AI Ready"
+ *   showTooltip
+ *   size="sm"
+ * />
+ * ```
+ */
+declare function LLMBadge({ text, showTooltip, tooltipContent, size, className, }: LLMBadgeProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Hook for LLM copy/view/download operations
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { copy, view, download, markdown, isCopying, isSuccess } = useLLMCopy({
+ *     content: {
+ *       title: 'My Article',
+ *       content: '<p>Article content...</p>',
+ *       url: 'https://example.com/article',
+ *     },
+ *     onSuccess: () => console.log('Copied!'),
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={copy} disabled={isCopying}>
+ *         {isSuccess ? 'Copied!' : 'Copy'}
+ *       </button>
+ *       <button onClick={download}>Download</button>
+ *       <pre>{view()}</pre>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useLLMCopy(options: UseLLMCopyOptions): UseLLMCopyReturn;
+
+/**
+ * Hook for Table of Contents functionality
+ *
+ * @example
+ * ```tsx
+ * function ArticlePage() {
+ *   const contentRef = useRef<HTMLDivElement>(null);
+ *   const { headings, activeId, scrollTo } = useTOC({
+ *     contentRef,
+ *     levels: ['h2', 'h3'],
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <nav>
+ *         {headings.map(h => (
+ *           <a
+ *             key={h.id}
+ *             href={`#${h.id}`}
+ *             onClick={(e) => { e.preventDefault(); scrollTo(h.id); }}
+ *             className={activeId === h.id ? 'active' : ''}
+ *           >
+ *             {h.text}
+ *           </a>
+ *         ))}
+ *       </nav>
+ *       <div ref={contentRef}>
+ *         <h2 id="intro">Introduction</h2>
+ *         <p>Content...</p>
+ *       </div>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useTOC(options: UseTOCOptions): UseTOCReturn;
+/**
+ * Build nested TOC structure from flat headings
+ */
+declare function buildNestedTOC(headings: TOCHeading[]): TOCHeading[];
+/**
+ * Hook for keyboard navigation in TOC
+ */
+declare function useTOCKeyboard(headings: TOCHeading[], activeId: string | null, scrollTo: (id: string) => void): void;
+
+/**
+ * Hook for analytics tracking
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { track, trackCopy, trackView, trackDownload } = useAnalytics({
+ *     endpoint: '/api/analytics',
+ *     metadata: { contentId: 'article-123' },
+ *   });
+ *
+ *   return (
+ *     <button onClick={trackCopy}>Copy</button>
+ *   );
+ * }
+ * ```
+ */
+declare function useAnalytics(options?: UseAnalyticsOptions): UseAnalyticsReturn;
+/**
+ * Create a simple analytics tracker function (non-hook version)
+ */
+declare function createAnalyticsTracker(endpoint: string): (action: CopyAction, contentId?: string, metadata?: Record<string, unknown>) => Promise<void>;
+
+/**
+ * HTML to Markdown Converter
+ * Converts HTML content to clean markdown format
+ */
+
+/**
+ * Convert HTML string to Markdown
+ */
+declare function htmlToMarkdown(html: string, options?: HTMLToMarkdownOptions): string;
+
+/**
+ * Clipboard Utilities
+ * Cross-browser clipboard operations
+ */
+/**
+ * Copy text to clipboard
+ * Uses modern Clipboard API with fallback for older browsers
+ */
+declare function copyToClipboard(text: string): Promise<boolean>;
+
+/**
+ * Download Utilities
+ * File download functionality
+ */
+
+/**
+ * Download content as a file
+ */
+declare function downloadAsFile(content: string, options?: DownloadOptions): void;
+
+/**
+ * Server-side Markdown Generation
+ * Generate LLM-ready markdown from content
+ */
+
+/**
+ * Generate complete markdown output from LLM content
+ */
+declare function generateMarkdown(content: LLMContent): MarkdownOutput;
+/**
+ * Generate markdown string only (without metadata)
+ */
+declare function generateMarkdownString(content: LLMContent): string;
+/**
+ * Convert LLMContent to plain text (for previews, etc.)
+ */
+declare function contentToPlainText(content: LLMContent): string;
+
+/**
+ * LLMs.txt Generator
+ * Generate sitemap-style content listing for AI crawlers
+ * Follows the llms.txt specification
+ */
+
+/**
+ * Generate llms.txt content
+ */
+declare function generateLLMsTxt(config: LLMsTxtConfig): string;
+
+/**
+ * LLMs.txt API Route Handler
+ * Creates an API route handler for serving /llms.txt
+ */
+
+interface LLMsTxtHandlerOptions {
+    /** Function to get site configuration */
+    getSiteConfig: () => Promise<{
+        siteName: string;
+        siteDescription?: string;
+        siteUrl: string;
+    }>;
+    /** Function to get all content items */
+    getContent: () => Promise<LLMsTxtItem[]>;
+    /** Cache control header (default: 1 hour) */
+    cacheControl?: string;
+    /** Custom header text */
+    headerText?: string;
+    /** Custom footer text */
+    footerText?: string;
+}
+/**
+ * Create an API route handler for /llms.txt
+ *
+ * @example
+ * ```ts
+ * // app/llms.txt/route.ts
+ * import { createLLMsTxtHandler } from 'next-llm-ready/api';
+ *
+ * export const GET = createLLMsTxtHandler({
+ *   getSiteConfig: async () => ({
+ *     siteName: 'My Site',
+ *     siteDescription: 'A great website',
+ *     siteUrl: 'https://example.com',
+ *   }),
+ *   getContent: async () => {
+ *     const posts = await getAllPosts();
+ *     return posts.map(post => ({
+ *       title: post.title,
+ *       url: `https://example.com/blog/${post.slug}`,
+ *       type: 'post',
+ *       date: post.date,
+ *     }));
+ *   },
+ * });
+ * ```
+ */
+declare function createLLMsTxtHandler(options: LLMsTxtHandlerOptions): (request: NextRequest) => Promise<NextResponse>;
+/**
+ * Create a Pages Router API handler for /api/llms.txt
+ *
+ * @example
+ * ```ts
+ * // pages/api/llms.txt.ts
+ * import { createLLMsTxtPageHandler } from 'next-llm-ready/api';
+ *
+ * export default createLLMsTxtPageHandler({
+ *   getSiteConfig: async () => ({ ... }),
+ *   getContent: async () => { ... },
+ * });
+ * ```
+ */
+declare function createLLMsTxtPageHandler(options: LLMsTxtHandlerOptions): (req: {
+    method?: string;
+}, res: {
+    status: (code: number) => {
+        end: (body?: string) => void;
+        json: (body: unknown) => void;
+    };
+    setHeader: (name: string, value: string) => void;
+}) => Promise<void>;
+
+/**
+ * Markdown API Route Handler
+ * Serves markdown content for ?llm=1 requests
+ */
+
+/**
+ * Create middleware to handle ?llm=1 query parameter
+ *
+ * @example
+ * ```ts
+ * // middleware.ts
+ * import { withLLMParam } from 'next-llm-ready/api';
+ *
+ * export default withLLMParam({
+ *   getContent: async (pathname) => {
+ *     // Extract slug and fetch content
+ *     const slug = pathname.split('/').pop();
+ *     const post = await getPostBySlug(slug);
+ *     if (!post) return null;
+ *     return {
+ *       title: post.title,
+ *       content: post.content,
+ *       url: `https://example.com${pathname}`,
+ *       date: post.date,
+ *     };
+ *   },
+ * });
+ * ```
+ */
+declare function withLLMParam(options: MarkdownHandlerOptions): (request: NextRequest) => Promise<NextResponse | undefined>;
+/**
+ * Create an API route handler for markdown endpoints
+ *
+ * @example
+ * ```ts
+ * // app/api/content/[slug]/route.ts
+ * import { createMarkdownHandler } from 'next-llm-ready/api';
+ *
+ * export const GET = createMarkdownHandler({
+ *   getContent: async (slug) => {
+ *     const post = await getPostBySlug(slug);
+ *     if (!post) return null;
+ *     return {
+ *       title: post.title,
+ *       content: post.content,
+ *       url: `https://example.com/blog/${slug}`,
+ *     };
+ *   },
+ * });
+ * ```
+ */
+declare function createMarkdownHandler(options: Omit<MarkdownHandlerOptions, 'getContent'> & {
+    getContent: (slug: string) => Promise<LLMContent | null>;
+}): (request: NextRequest, { params }: {
+    params: {
+        slug?: string;
+    };
+}) => Promise<NextResponse>;
+/**
+ * Helper to check if request has ?llm=1 parameter
+ */
+declare function hasLLMParam(request: NextRequest): boolean;
+
+/**
+ * Analytics API Route Handler
+ * Tracks copy/view/download events
+ */
+
+/**
+ * In-memory analytics storage (for development/testing)
+ */
+declare function createInMemoryStorage(): AnalyticsStorageAdapter;
+/**
+ * Create an API route handler for analytics tracking
+ *
+ * @example
+ * ```ts
+ * // app/api/analytics/route.ts
+ * import { createAnalyticsHandler, createInMemoryStorage } from 'next-llm-ready/api';
+ *
+ * const storage = createInMemoryStorage();
+ *
+ * export const POST = createAnalyticsHandler({
+ *   storage,
+ *   rateLimit: 100,
+ * });
+ *
+ * export const GET = async () => {
+ *   const events = await storage.getAll();
+ *   return NextResponse.json({ events });
+ * };
+ * ```
+ */
+declare function createAnalyticsHandler(options: AnalyticsHandlerOptions): (request: NextRequest) => Promise<NextResponse>;
+/**
+ * Create a Pages Router API handler for analytics
+ */
+declare function createAnalyticsPageHandler(options: AnalyticsHandlerOptions): (req: {
+    method?: string;
+    body?: unknown;
+    headers?: {
+        [key: string]: string | string[] | undefined;
+    };
+}, res: {
+    status: (code: number) => {
+        end: (body?: string) => void;
+        json: (body: unknown) => void;
+    };
+    setHeader: (name: string, value: string) => void;
+}) => Promise<void>;
+/**
+ * Aggregate analytics events by action type
+ */
+declare function aggregateEvents(storage: AnalyticsStorageAdapter): Promise<Record<string, number>>;
+/**
+ * Get events for a specific content ID
+ */
+declare function getEventsForContent(storage: AnalyticsStorageAdapter, contentId: string): Promise<AnalyticsEvent[]>;
+
+export { type AnalyticsConfig, type AnalyticsEvent, type AnalyticsHandlerOptions, type AnalyticsStorageAdapter, type CopyAction, CopyButton, type CopyButtonProps, CopyDropdown, type CopyDropdownProps, type DownloadOptions, type DropdownMenuItem, type HTMLToMarkdownOptions, LLMBadge, type LLMBadgeProps, type LLMContent, type LLMReadyConfig, type LLMsTxtConfig, type LLMsTxtHandlerOptions, type LLMsTxtItem, type MarkdownHandlerOptions, type MarkdownOutput, TOC, type TOCHeading, TOCMobile, type TOCProps, type ThemeConfig, type UseAnalyticsOptions, type UseAnalyticsReturn, type UseLLMCopyOptions, type UseLLMCopyReturn, type UseTOCOptions, type UseTOCReturn, aggregateEvents, buildNestedTOC, contentToPlainText, copyToClipboard, createAnalyticsHandler, createAnalyticsPageHandler, createAnalyticsTracker, createInMemoryStorage, createLLMsTxtHandler, createLLMsTxtPageHandler, createMarkdownHandler, downloadAsFile, generateLLMsTxt, generateMarkdown, generateMarkdownString, getEventsForContent, hasLLMParam, htmlToMarkdown, useAnalytics, useLLMCopy, useTOC, useTOCKeyboard, withLLMParam };