@xexr/blog-platform 0.2.0

package/dist/index.d.mts

@@ -0,0 +1,1799 @@
+import { PublishedArticle, PublishedSite, PublishResult, PublishedAuthor } from './types/index.mjs';
+export { PublishPayload } from './types/index.mjs';
+import * as React from 'react';
+import React__default from 'react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { ClassValue } from 'clsx';
+import { NextRequest, NextResponse } from 'next/server';
+import * as drizzle_orm_sqlite_core from 'drizzle-orm/sqlite-core';
+import { LibSQLDatabase } from 'drizzle-orm/libsql';
+
+interface BlogHomePageProps {
+    articles: PublishedArticle[];
+    siteName?: string;
+    siteTagline?: string;
+    className?: string;
+    /** Site data for structured data generation */
+    site?: PublishedSite;
+    /** Whether to include structured data */
+    includeStructuredData?: boolean;
+    /** Pagination configuration */
+    pagination?: {
+        currentPage: number;
+        totalPages: number;
+        baseUrl?: string;
+    };
+}
+/**
+ * Blog home page component that displays a list of published articles.
+ *
+ * This component is designed to be used by customers who install the
+ * @xexr/blog-platform package. It provides a clean, SEO-friendly
+ * article listing with proper metadata.
+ */
+declare function BlogHomePage({ articles, siteName, siteTagline, className, site, includeStructuredData, pagination, }: BlogHomePageProps): React__default.JSX.Element;
+/**
+ * Generate metadata for the blog home page for SEO optimization.
+ * This function should be used in the Next.js metadata API.
+ */
+declare function generateBlogHomeMetadata(siteName?: string, siteDescription?: string, siteUrl?: string, pagination?: {
+    currentPage: number;
+    totalPages: number;
+}): {
+    title: string;
+    description: string;
+    openGraph: {
+        url?: string | undefined;
+        title: string;
+        description: string;
+        type: string;
+    };
+    twitter: {
+        card: string;
+        title: string;
+        description: string;
+    };
+    alternates: {
+        canonical?: string | undefined;
+    };
+    other: {
+        next?: string | undefined;
+        prev?: string | undefined;
+    };
+};
+
+interface ArticlePageProps {
+    article: PublishedArticle;
+    className?: string;
+    /** Optional navigation links */
+    navigation?: {
+        backToHome?: {
+            url: string;
+            label?: string;
+        };
+        previousArticle?: {
+            url: string;
+            title: string;
+        };
+        nextArticle?: {
+            url: string;
+            title: string;
+        };
+    };
+}
+declare function ArticlePage({ article, className, navigation, }: ArticlePageProps): React__default.JSX.Element;
+/**
+ * Generate metadata for the article page for SEO optimization.
+ * This function should be used in the Next.js metadata API.
+ */
+declare function generateArticleMetadata(article: PublishedArticle): {
+    title: string;
+    description: string;
+    keywords: string;
+    authors: {
+        name: string;
+    }[] | undefined;
+    openGraph: {
+        title: string;
+        description: string;
+        type: string;
+        url: string;
+        images: {
+            url: string;
+            alt: string;
+        }[] | undefined;
+        publishedTime: string;
+        modifiedTime: string;
+        authors: string[] | undefined;
+        siteName: string;
+    };
+    twitter: {
+        card: string;
+        title: string;
+        description: string;
+        images: string[] | undefined;
+    };
+    alternates: {
+        canonical: string;
+    };
+};
+
+interface PaginationProps {
+    /** Current page number (1-indexed) */
+    currentPage: number;
+    /** Total number of pages */
+    totalPages: number;
+    /** Base URL for pagination links (e.g., "/blog") */
+    baseUrl: string;
+    /** Additional CSS classes */
+    className?: string;
+    /** Maximum number of page links to show around current page */
+    maxVisiblePages?: number;
+    /** Show/hide previous and next buttons */
+    showPrevNext?: boolean;
+    /** Show/hide first and last page links */
+    showFirstLast?: boolean;
+    /** Custom labels for navigation */
+    labels?: {
+        previous?: string;
+        next?: string;
+        first?: string;
+        last?: string;
+    };
+}
+/**
+ * Pagination component for blog articles listing.
+ *
+ * Provides SEO-friendly pagination with proper URL structure,
+ * keyboard navigation, and accessibility features.
+ */
+declare function Pagination$1({ currentPage, totalPages, baseUrl, className, maxVisiblePages, showPrevNext, showFirstLast, }: PaginationProps): React__default.JSX.Element | null;
+/**
+ * Hook to calculate pagination metadata from URL parameters.
+ * Useful for extracting current page from Next.js searchParams.
+ */
+declare function usePagination(searchParams: Record<string, string | string[] | undefined>, itemsPerPage?: number): {
+    currentPage: number;
+    itemsPerPage: number;
+    offset: number;
+    calculateTotalPages: (totalItems: number) => number;
+};
+/**
+ * Generate pagination metadata for SEO.
+ * Provides canonical URLs, next/prev relationships for search engines.
+ */
+declare function generatePaginationMetadata(currentPage: number, totalPages: number, baseUrl: string, siteUrl?: string): {
+    alternates: {
+        canonical?: string | undefined;
+    };
+    other: {
+        next?: string | undefined;
+        prev?: string | undefined;
+    };
+};
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "destructive" | "outline" | "secondary" | "ghost" | "link" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): React.JSX.Element;
+
+declare function Card({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardTitle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardDescription({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+
+declare function Pagination({ className, ...props }: React.ComponentProps<"nav">): React.JSX.Element;
+declare function PaginationContent({ className, ...props }: React.ComponentProps<"ul">): React.JSX.Element;
+declare function PaginationItem({ ...props }: React.ComponentProps<"li">): React.JSX.Element;
+type PaginationLinkProps = {
+    isActive?: boolean;
+    size?: "default" | "sm" | "lg" | "icon";
+} & React.ComponentProps<"a">;
+declare function PaginationLink({ className, isActive, size, ...props }: PaginationLinkProps): React.JSX.Element;
+declare function PaginationPrevious({ className, ...props }: React.ComponentProps<typeof PaginationLink>): React.JSX.Element;
+declare function PaginationNext({ className, ...props }: React.ComponentProps<typeof PaginationLink>): React.JSX.Element;
+declare function PaginationEllipsis({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+
+declare function cn(...inputs: ClassValue[]): string;
+
+/**
+ * Authentication configuration interface
+ * Customers can implement this to customize authentication behavior
+ */
+interface AuthConfig {
+    /**
+     * Validate an authentication token
+     * @param token - The token to validate
+     * @returns Promise that resolves to validation result
+     */
+    validateToken(token: string): Promise<AuthResult>;
+    /**
+     * Extract token from request
+     * @param request - The incoming request
+     * @returns The extracted token or null if not found
+     */
+    extractToken?(request: NextRequest): string | null;
+    /**
+     * Custom error messages for authentication failures
+     */
+    errorMessages?: {
+        missing?: string;
+        invalid?: string;
+        expired?: string;
+    };
+}
+/**
+ * Authentication result from token validation
+ */
+interface AuthResult {
+    /** Whether the token is valid */
+    valid: boolean;
+    /** Error code if invalid */
+    errorCode?: "missing" | "invalid" | "expired";
+    /** Additional user/context information */
+    context?: Record<string, unknown>;
+}
+/**
+ * Default token extraction from Authorization header
+ * Supports both "Bearer <token>" and "Token <token>" formats
+ */
+declare function extractTokenFromHeader(request: NextRequest): string | null;
+/**
+ * Simple API key based authentication implementation
+ * Customers can extend this or provide their own AuthConfig
+ */
+declare class ApiKeyAuth implements AuthConfig {
+    private validApiKeys;
+    constructor(apiKeys: string[]);
+    validateToken(token: string): Promise<AuthResult>;
+    extractToken: (request: NextRequest) => string | null;
+    private hashToken;
+}
+/**
+ * Environment variable based authentication
+ * Reads API keys from environment variables
+ */
+declare class EnvAuth extends ApiKeyAuth {
+    constructor(envVarName?: string);
+}
+/**
+ * No-op authentication for development/testing
+ * WARNING: Never use this in production!
+ */
+declare class NoAuth implements AuthConfig {
+    validateToken(): Promise<AuthResult>;
+    extractToken(): string | null;
+}
+/**
+ * Uninitialized authentication - rejects all requests
+ * This is the secure default before initialization
+ */
+declare class UninitializedAuth implements AuthConfig {
+    private hasWarned;
+    validateToken(_token: string): Promise<AuthResult>;
+}
+declare global {
+    var __BLOG_PLATFORM_AUTH_CONFIG__: AuthConfig | undefined;
+}
+/**
+ * Set the authentication configuration
+ * Customers should call this in their app initialization
+ */
+declare function setAuthConfig(config: AuthConfig): void;
+/**
+ * Get the current authentication configuration
+ */
+declare function getAuthConfig(): AuthConfig;
+/**
+ * Initialize authentication with environment-based API keys
+ * This is a convenience function for common setups
+ */
+declare function initEnvAuth(envVarName?: string): void;
+/**
+ * Utility to check if current environment should skip authentication
+ * Useful for development and testing
+ */
+declare function shouldSkipAuth(): boolean;
+
+/**
+ * Database interface for blog platform storage
+ *
+ * This provides a simple interface for storing published articles
+ * without coupling to any specific database implementation.
+ * Customers can implement this interface with their preferred database.
+ */
+
+interface BlogPlatformStorage {
+    /**
+     * Store a published article
+     */
+    saveArticle(article: PublishedArticle, idempotencyKey: string): Promise<PublishResult>;
+    /**
+     * Get an article by slug
+     */
+    getArticle(slug: string): Promise<PublishedArticle | null>;
+    /**
+     * List all published articles
+     */
+    listArticles(options?: {
+        limit?: number;
+        offset?: number;
+        sortBy?: "publishedAt" | "updatedAt";
+        order?: "asc" | "desc";
+    }): Promise<{
+        articles: PublishedArticle[];
+        total: number;
+    }>;
+    /**
+     * Remove an article by slug
+     */
+    removeArticle(slug: string, idempotencyKey: string): Promise<PublishResult>;
+    /**
+     * Check if an operation was already performed (idempotency)
+     */
+    checkIdempotency(idempotencyKey: string): Promise<PublishResult | null>;
+    /**
+     * Store the result of an operation for idempotency
+     */
+    storeOperationResult(idempotencyKey: string, result: PublishResult): Promise<void>;
+}
+/**
+ * Default in-memory storage implementation for development/testing
+ * IMPORTANT: This is not suitable for production use!
+ */
+declare class InMemoryStorage implements BlogPlatformStorage {
+    private articles;
+    private operations;
+    saveArticle(article: PublishedArticle, idempotencyKey: string): Promise<PublishResult>;
+    getArticle(slug: string): Promise<PublishedArticle | null>;
+    listArticles(options?: {
+        limit?: number;
+        offset?: number;
+        sortBy?: "publishedAt" | "updatedAt";
+        order?: "asc" | "desc";
+    }): Promise<{
+        articles: PublishedArticle[];
+        total: number;
+    }>;
+    removeArticle(slug: string, idempotencyKey: string): Promise<PublishResult>;
+    checkIdempotency(idempotencyKey: string): Promise<PublishResult | null>;
+    storeOperationResult(idempotencyKey: string, result: PublishResult): Promise<void>;
+}
+declare function getStorage(): BlogPlatformStorage;
+declare function setStorage(storage: BlogPlatformStorage): void;
+
+/**
+ * Rate limiting for blog platform API endpoints
+ *
+ * This implements rate limiting using Upstash Redis to prevent abuse
+ * and ensure fair usage across all API consumers.
+ */
+
+/**
+ * Rate limit configuration interface
+ * Allows customers to customize rate limiting behavior
+ */
+interface RateLimitConfig {
+    /** Upstash Redis REST URL */
+    redisUrl: string;
+    /** Upstash Redis REST token */
+    redisToken: string;
+    /** Requests per minute limit (default: 5) */
+    requestsPerMinute?: number;
+    /** Redis key prefix for rate limiting (default: "blog-platform-ratelimit") */
+    keyPrefix?: string;
+    /** Enable analytics (default: true) */
+    analytics?: boolean;
+}
+/**
+ * Rate limit result
+ */
+interface RateLimitResult {
+    /** Whether the request is allowed */
+    success: boolean;
+    /** Number of requests remaining in current window */
+    remaining: number;
+    /** When the rate limit window resets (Unix timestamp) */
+    reset: number;
+    /** Total requests allowed per window */
+    limit: number;
+    /** Current request count in window */
+    count: number;
+}
+/**
+ * Configure the rate limiter
+ * This must be called during app initialization
+ */
+declare function configureRateLimit(config: RateLimitConfig): void;
+/**
+ * Auto-configure rate limiting from environment variables
+ * Uses UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN
+ */
+declare function autoConfigureRateLimit(): void;
+/**
+ * Check rate limit for a given identifier (typically an auth token)
+ * @param identifier - Unique identifier (usually the authentication token)
+ * @returns Rate limit result
+ */
+declare function checkRateLimit(identifier: string): Promise<RateLimitResult>;
+/**
+ * Create a rate limit error response
+ * @param rateLimitResult - The rate limit result that failed
+ * @param idempotencyKey - Optional idempotency key from request
+ * @returns PublishResult with rate limit error
+ */
+declare function createRateLimitErrorResponse(rateLimitResult: RateLimitResult, idempotencyKey?: string): PublishResult;
+/**
+ * Rate limiting middleware for API routes
+ * @param identifier - Unique identifier for rate limiting (typically auth token)
+ * @param idempotencyKey - Optional idempotency key from request
+ * @returns Rate limit result or error response
+ */
+declare function enforceRateLimit(identifier: string, idempotencyKey?: string): Promise<{
+    allowed: true;
+    rateLimitResult: RateLimitResult;
+} | {
+    allowed: false;
+    errorResponse: PublishResult;
+}>;
+/**
+ * Get rate limit headers for HTTP responses
+ * @param rateLimitResult - Rate limit result
+ * @returns Headers object for HTTP response
+ */
+declare function getRateLimitHeaders(rateLimitResult: RateLimitResult): Record<string, string>;
+
+/**
+ * Initialization utilities for the blog platform package
+ *
+ * This module provides convenient setup functions for customers
+ * to configure authentication, storage, and other platform features.
+ */
+
+declare global {
+    var __BLOG_PLATFORM_INITIALISED__: boolean | undefined;
+}
+/**
+ * Configuration options for blog platform initialization
+ */
+interface BlogPlatformConfig {
+    /** Authentication configuration (REQUIRED) */
+    auth: AuthConfig;
+    /** Custom storage implementation */
+    storage?: BlogPlatformStorage;
+    /** Custom rate limiting configuration */
+    rateLimit?: RateLimitConfig;
+    /** Whether to automatically configure rate limiting from environment */
+    autoRateLimit?: boolean;
+}
+/**
+ * Initialize the blog platform with custom configuration
+ *
+ * This should be called once during your app startup, typically in:
+ * - Next.js: middleware.ts or layout.tsx
+ * - Express: app startup
+ * - Other frameworks: main entry point
+ *
+ * @param config - Configuration options (auth is REQUIRED)
+ *
+ * @example
+ * ```typescript
+ * // Environment-based API key authentication
+ * initBlogPlatform({
+ *   auth: new EnvAuth(), // Reads from BLOG_PLATFORM_API_KEYS
+ * });
+ *
+ * // Custom environment variable
+ * initBlogPlatform({
+ *   auth: new EnvAuth("MY_BLOG_API_KEYS"),
+ * });
+ *
+ * // Custom authentication provider
+ * initBlogPlatform({
+ *   auth: new CustomAuthProvider(),
+ *   storage: new PostgresStorage(connectionString),
+ *   rateLimit: {
+ *     redisUrl: "https://...",
+ *     redisToken: "...",
+ *     requestsPerMinute: 10
+ *   }
+ * });
+ *
+ * // Disable rate limiting for testing
+ * initBlogPlatform({
+ *   auth: new NoAuth(), // Development only!
+ *   autoRateLimit: false
+ * });
+ * ```
+ */
+declare function initBlogPlatform(config: BlogPlatformConfig): void;
+/**
+ * Initialize the blog platform only once per process.
+ * Safe to call from multiple modules (e.g., layout + API routes).
+ *
+ * @param config - Configuration options (auth is REQUIRED)
+ */
+declare function initBlogPlatformOnce(config: BlogPlatformConfig): void;
+/**
+ * Quick setup for development/testing
+ * WARNING: Disables authentication - never use in production!
+ * Uses NoAuth (accepts all requests), in-memory storage, and disables rate limiting
+ */
+declare function initBlogPlatformDev(): void;
+/**
+ * Production setup with environment-based API keys and rate limiting
+ * Requires BLOG_PLATFORM_API_KEYS (or custom env var), UPSTASH_REDIS_REST_URL,
+ * and UPSTASH_REDIS_REST_TOKEN environment variables
+ *
+ * @param apiKeysEnvVar - Optional custom environment variable name for API keys (default: BLOG_PLATFORM_API_KEYS)
+ */
+declare function initBlogPlatformProd(apiKeysEnvVar?: string): void;
+
+declare const bpArticles: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+    name: "bp_articles";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "id";
+            tableName: "bp_articles";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        slug: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "slug";
+            tableName: "bp_articles";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        title: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "title";
+            tableName: "bp_articles";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        excerpt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "excerpt";
+            tableName: "bp_articles";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        content: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "content";
+            tableName: "bp_articles";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        readingSeconds: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "reading_seconds";
+            tableName: "bp_articles";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        wordCount: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "word_count";
+            tableName: "bp_articles";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        publishedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "published_at";
+            tableName: "bp_articles";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        updatedAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "updated_at";
+            tableName: "bp_articles";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        featuredImage: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "featured_image";
+            tableName: "bp_articles";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        featuredImageAlt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "featured_image_alt";
+            tableName: "bp_articles";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        authorJson: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "author_json";
+            tableName: "bp_articles";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        siteJson: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "site_json";
+            tableName: "bp_articles";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        metaJson: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "meta_json";
+            tableName: "bp_articles";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        version: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "version";
+            tableName: "bp_articles";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+declare const bpOperations: drizzle_orm_sqlite_core.SQLiteTableWithColumns<{
+    name: "bp_operations";
+    schema: undefined;
+    columns: {
+        key: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "key";
+            tableName: "bp_operations";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        resultJson: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "result_json";
+            tableName: "bp_operations";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "created_at";
+            tableName: "bp_operations";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        expiresAt: drizzle_orm_sqlite_core.SQLiteColumn<{
+            name: "expires_at";
+            tableName: "bp_operations";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+interface DrizzleStorageOptions {
+    operationTtlMs?: number;
+}
+/**
+ * Drizzle-backed durable storage adapter.
+ * Pass a Drizzle Database instance created with drizzle-orm/libsql.
+ */
+declare class DrizzleStorage implements BlogPlatformStorage {
+    private readonly db;
+    private readonly options;
+    constructor(db: LibSQLDatabase, options?: DrizzleStorageOptions);
+    saveArticle(article: PublishedArticle, idempotencyKey: string): Promise<PublishResult>;
+    getArticle(slug: string): Promise<PublishedArticle | null>;
+    listArticles(options?: {
+        limit?: number;
+        offset?: number;
+        sortBy?: "publishedAt" | "updatedAt";
+        order?: "asc" | "desc";
+    }): Promise<{
+        articles: PublishedArticle[];
+        total: number;
+    }>;
+    removeArticle(slug: string, idempotencyKey: string): Promise<PublishResult>;
+    checkIdempotency(idempotencyKey: string): Promise<PublishResult | null>;
+    storeOperationResult(idempotencyKey: string, result: PublishResult): Promise<void>;
+}
+/**
+ * Helper: Return SQL strings for creating required tables.
+ * Consumers can embed these in their migrations.
+ */
+declare function getDrizzleAdapterSql(): {
+    createArticles: string;
+    createOperations: string;
+};
+
+/**
+ * SEO utilities for canonical URL generation and validation.
+ *
+ * These utilities ensure proper canonical URL structure for SEO optimization,
+ * preventing duplicate content issues and improving search engine indexing.
+ */
+
+/**
+ * Configuration options for canonical URL generation.
+ */
+interface CanonicalUrlOptions {
+    /** Whether to force HTTPS protocol (default: true) */
+    forceHttps?: boolean;
+    /** Whether to remove trailing slashes (default: true) */
+    removeTrailingSlash?: boolean;
+    /** Custom domain override (uses site.domain if not provided) */
+    domain?: string;
+    /** Custom path prefix (default: '/blog') */
+    pathPrefix?: string;
+}
+/**
+ * Normalizes a domain by ensuring proper protocol and removing trailing slashes.
+ *
+ * @param domain - The domain to normalize
+ * @param forceHttps - Whether to force HTTPS protocol
+ * @returns The normalized domain
+ *
+ * @example
+ * ```typescript
+ * normalizeDomain('example.com') // 'https://example.com'
+ * normalizeDomain('http://example.com/') // 'https://example.com'
+ * normalizeDomain('https://example.com', false) // 'https://example.com'
+ * ```
+ */
+declare function normalizeDomain(domain: string, forceHttps?: boolean): string;
+/**
+ * Validates and normalizes a slug for URL usage.
+ *
+ * @param slug - The slug to validate and normalize
+ * @returns The normalized slug
+ * @throws Error if slug is invalid
+ *
+ * @example
+ * ```typescript
+ * normalizeSlug('hello-world') // 'hello-world'
+ * normalizeSlug('Hello World!') // throws Error
+ * normalizeSlug('hello--world') // 'hello-world'
+ * ```
+ */
+declare function normalizeSlug(slug: string): string;
+/**
+ * Generates a canonical URL for an article.
+ *
+ * @param article - The published article
+ * @param options - Configuration options for URL generation
+ * @returns The canonical URL
+ * @throws Error if article or site data is invalid
+ *
+ * @example
+ * ```typescript
+ * const article = {
+ *   slug: 'hello-world',
+ *   site: { domain: 'example.com' },
+ *   // ... other fields
+ * };
+ *
+ * generateCanonicalUrl(article)
+ * // 'https://example.com/blog/hello-world'
+ *
+ * generateCanonicalUrl(article, { pathPrefix: '/posts' })
+ * // 'https://example.com/posts/hello-world'
+ * ```
+ */
+declare function generateCanonicalUrl(article: PublishedArticle, options?: CanonicalUrlOptions): string;
+/**
+ * Generates a canonical URL for an article from site and slug data.
+ * Useful when you don't have a full PublishedArticle object.
+ *
+ * @param site - The published site
+ * @param slug - The article slug
+ * @param options - Configuration options for URL generation
+ * @returns The canonical URL
+ *
+ * @example
+ * ```typescript
+ * const site = { domain: 'example.com', ... };
+ * generateCanonicalUrlFromSlug(site, 'hello-world')
+ * // 'https://example.com/blog/hello-world'
+ * ```
+ */
+declare function generateCanonicalUrlFromSlug(site: PublishedSite, slug: string, options?: CanonicalUrlOptions): string;
+/**
+ * Validates if a URL is a valid canonical URL format.
+ *
+ * @param url - The URL to validate
+ * @returns True if the URL is valid for canonical use
+ *
+ * @example
+ * ```typescript
+ * isValidCanonicalUrl('https://example.com/blog/hello-world') // true
+ * isValidCanonicalUrl('http://example.com/blog/hello-world') // true
+ * isValidCanonicalUrl('example.com/blog/hello-world') // false (missing protocol)
+ * isValidCanonicalUrl('https://example.com/blog/hello world') // false (spaces)
+ * ```
+ */
+declare function isValidCanonicalUrl(url: string): boolean;
+/**
+ * Extracts the base URL (protocol + hostname + port) from a canonical URL.
+ *
+ * @param canonicalUrl - The canonical URL
+ * @returns The base URL
+ *
+ * @example
+ * ```typescript
+ * getBaseUrl('https://example.com/blog/hello-world') // 'https://example.com'
+ * getBaseUrl('https://blog.example.com:8080/posts/test') // 'https://blog.example.com:8080'
+ * ```
+ */
+declare function getBaseUrl(canonicalUrl: string): string;
+/**
+ * Updates an article's canonical URL in its meta field.
+ *
+ * @param article - The article to update
+ * @param options - Configuration options for URL generation
+ * @returns A new article object with updated canonical URL
+ *
+ * @example
+ * ```typescript
+ * const updatedArticle = updateArticleCanonicalUrl(article);
+ * console.log(updatedArticle.meta.canonicalUrl); // Generated canonical URL
+ * ```
+ */
+declare function updateArticleCanonicalUrl(article: PublishedArticle, options?: CanonicalUrlOptions): PublishedArticle;
+
+/**
+ * Metadata generation utilities for SEO meta tags, OpenGraph, and Twitter Cards.
+ *
+ * These utilities create comprehensive metadata for blog articles and pages,
+ * optimizing for search engines and social media sharing platforms.
+ */
+
+/**
+ * Configuration options for metadata generation.
+ */
+interface MetadataOptions {
+    /** Canonical URL generation options */
+    canonical?: CanonicalUrlOptions;
+    /** OpenGraph configuration */
+    openGraph?: {
+        /** Site name for OpenGraph */
+        siteName?: string;
+        /** Default OpenGraph image URL */
+        defaultImage?: string;
+        /** OpenGraph locale (defaults to site locale) */
+        locale?: string;
+        /** OpenGraph type (defaults to 'article') */
+        type?: 'article' | 'website';
+    };
+    /** Twitter Card configuration */
+    twitter?: {
+        /** Twitter site handle (e.g., '@blogname') */
+        site?: string;
+        /** Twitter creator handle (e.g., '@authorname') */
+        creator?: string;
+        /** Default Twitter card type */
+        cardType?: 'summary' | 'summary_large_image' | 'app' | 'player';
+    };
+    /** Additional meta tag configuration */
+    meta?: {
+        /** Robots meta tag directive */
+        robots?: string;
+        /** Viewport meta tag content */
+        viewport?: string;
+        /** Theme color for mobile browsers */
+        themeColor?: string;
+        /** Application name */
+        applicationName?: string;
+    };
+}
+/**
+ * Generated metadata for HTML head section.
+ */
+interface GeneratedMetadata {
+    /** Basic HTML meta tags */
+    meta: MetaTag[];
+    /** OpenGraph meta tags */
+    openGraph: MetaTag[];
+    /** Twitter Card meta tags */
+    twitter: MetaTag[];
+    /** Link tags (canonical, etc.) */
+    links: LinkTag[];
+    /** Title tag content */
+    title: string;
+    /** Meta description content */
+    description: string;
+    /** Canonical URL */
+    canonicalUrl: string;
+}
+/**
+ * HTML meta tag representation.
+ */
+interface MetaTag {
+    name?: string;
+    property?: string;
+    content: string;
+    httpEquiv?: string;
+}
+/**
+ * HTML link tag representation.
+ */
+interface LinkTag {
+    rel: string;
+    href: string;
+    type?: string;
+    title?: string;
+}
+/**
+ * Generates metadata for a blog home page or listing page.
+ *
+ * @param site - The published site information
+ * @param options - Metadata generation options
+ * @param pageInfo - Optional page-specific information
+ * @returns Complete metadata for HTML head section
+ *
+ * @example
+ * ```typescript
+ * const metadata = generateSiteMetadata(site, {
+ *   openGraph: {
+ *     defaultImage: 'https://example.com/og-home.jpg'
+ *   }
+ * }, {
+ *   title: 'Latest Articles',
+ *   description: 'Browse our latest blog posts',
+ *   path: '/blog'
+ * });
+ * ```
+ */
+declare function generateSiteMetadata(site: PublishedSite, options?: MetadataOptions, pageInfo?: {
+    title?: string;
+    description?: string;
+    path?: string;
+    pageNumber?: number;
+}): GeneratedMetadata;
+/**
+ * Converts metadata to HTML string for server-side rendering.
+ *
+ * @param metadata - Generated metadata object
+ * @returns HTML string for head section
+ *
+ * @example
+ * ```typescript
+ * const metadata = generateArticleMetadata(article);
+ * const htmlHead = metadataToHtml(metadata);
+ * // Use in server-side rendering
+ * ```
+ */
+declare function metadataToHtml(metadata: GeneratedMetadata): string;
+/**
+ * Validates that metadata meets SEO best practices.
+ *
+ * @param metadata - Generated metadata to validate
+ * @returns Validation results with warnings and errors
+ *
+ * @example
+ * ```typescript
+ * const metadata = generateArticleMetadata(article);
+ * const validation = validateMetadata(metadata);
+ *
+ * if (validation.errors.length > 0) {
+ *   console.error('Metadata errors:', validation.errors);
+ * }
+ * ```
+ */
+declare function validateMetadata(metadata: GeneratedMetadata): {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+};
+
+/**
+ * Next.js-compatible sitemap generation utilities for blog platform integration.
+ *
+ * These utilities generate sitemap entries that follow Next.js MetadataRoute.Sitemap
+ * conventions, allowing seamless integration with existing Next.js applications.
+ *
+ * @example Integration with existing Next.js sitemap:
+ * ```typescript
+ * // app/sitemap.ts
+ * import { generateBlogSitemapEntries } from '@xexr/blog-platform';
+ * import type { MetadataRoute } from 'next';
+ *
+ * export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
+ *   // Your existing routes
+ *   const staticRoutes = [
+ *     { url: 'https://yoursite.com', lastModified: new Date(), priority: 1 },
+ *     { url: 'https://yoursite.com/about', lastModified: new Date(), priority: 0.8 }
+ *   ];
+ *
+ *   // Blog platform entries
+ *   const blogEntries = await generateBlogSitemapEntries(blogConfig);
+ *
+ *   return [...staticRoutes, ...blogEntries];
+ * }
+ * ```
+ */
+
+/**
+ * Configuration options for sitemap generation.
+ */
+interface SitemapOptions {
+    /** Canonical URL configuration */
+    canonical?: CanonicalUrlOptions;
+    /** Whether to include author pages in sitemap */
+    includeAuthorPages?: boolean;
+    /** Whether to include pagination pages in sitemap */
+    includePaginationPages?: boolean;
+    /** Number of articles per page for pagination calculation */
+    articlesPerPage?: number;
+    /** Maximum number of sitemap entries (defaults to 50,000 per Google guidelines) */
+    maxEntries?: number;
+    /** Change frequency for different page types */
+    changeFrequency?: {
+        /** Change frequency for blog home page */
+        homePage?: SitemapChangeFreq;
+        /** Change frequency for article pages */
+        articles?: SitemapChangeFreq;
+        /** Change frequency for author pages */
+        authorPages?: SitemapChangeFreq;
+        /** Change frequency for pagination pages */
+        paginationPages?: SitemapChangeFreq;
+    };
+    /** Priority values for different page types */
+    priority?: {
+        /** Priority for blog home page (0.0-1.0) */
+        homePage?: number;
+        /** Priority for article pages (0.0-1.0) */
+        articles?: number;
+        /** Priority for author pages (0.0-1.0) */
+        authorPages?: number;
+        /** Priority for pagination pages (0.0-1.0) */
+        paginationPages?: number;
+    };
+}
+/**
+ * Valid sitemap change frequency values as per XML sitemap standard.
+ */
+type SitemapChangeFreq = 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+/**
+ * Next.js MetadataRoute.Sitemap compatible entry.
+ * This matches the expected format for Next.js sitemap generation.
+ */
+interface NextjsSitemapEntry {
+    /** The URL of the page */
+    url: string;
+    /** Last modification date */
+    lastModified?: string | Date;
+    /** Change frequency hint for search engines */
+    changeFrequency?: SitemapChangeFreq;
+    /** Priority relative to other URLs on the site (0.0-1.0) */
+    priority?: number;
+    /** Alternate language versions (for i18n) */
+    alternates?: {
+        languages?: Record<string, string>;
+    };
+}
+/**
+ * Legacy XML sitemap entry format (for backward compatibility).
+ * @deprecated Use NextjsSitemapEntry for new implementations
+ */
+interface SitemapEntry {
+    /** The URL of the page */
+    loc: string;
+    /** Last modification date as ISO 8601 string */
+    lastmod?: string;
+    /** Change frequency hint for search engines */
+    changefreq?: SitemapChangeFreq;
+    /** Priority relative to other URLs on the site (0.0-1.0) */
+    priority?: number;
+}
+/**
+ * Complete sitemap data structure.
+ */
+interface SitemapData {
+    /** All URL entries in the sitemap */
+    entries: SitemapEntry[];
+    /** Total number of entries */
+    totalEntries: number;
+    /** Whether the sitemap was truncated due to size limits */
+    truncated: boolean;
+    /** Generation timestamp */
+    generatedAt: string;
+    /** Base URL used for canonical URL generation */
+    baseUrl: string;
+}
+/**
+ * Generates Next.js-compatible sitemap entries for blog platform integration.
+ *
+ * @param site - The published site information
+ * @param articles - Array of published articles
+ * @param authors - Array of published authors (optional)
+ * @param options - Sitemap generation options
+ * @returns Array of Next.js MetadataRoute.Sitemap compatible entries
+ *
+ * @example
+ * ```typescript
+ * // In your Next.js app/sitemap.ts file:
+ * import { generateBlogSitemapEntries } from '@xexr/blog-platform';
+ * import type { MetadataRoute } from 'next';
+ *
+ * export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
+ *   const blogEntries = await generateBlogSitemapEntries(site, articles, authors, {
+ *     includeAuthorPages: true,
+ *     includePaginationPages: true,
+ *     changeFrequency: { articles: 'monthly' }
+ *   });
+ *
+ *   return [
+ *     // Your existing site routes
+ *     { url: 'https://yoursite.com', lastModified: new Date(), priority: 1 },
+ *     { url: 'https://yoursite.com/about', lastModified: new Date() },
+ *     // Blog entries
+ *     ...blogEntries
+ *   ];
+ * }
+ * ```
+ */
+declare function generateBlogSitemapEntries(site: PublishedSite, articles: readonly PublishedArticle[], authors?: readonly PublishedAuthor[], options?: SitemapOptions): Promise<NextjsSitemapEntry[]>;
+/**
+ * Legacy sitemap generation for backward compatibility.
+ * @deprecated Use generateBlogSitemapEntries for Next.js integration
+ *
+ * @param site - The published site information
+ * @param articles - Array of published articles
+ * @param authors - Array of published authors (optional)
+ * @param options - Sitemap generation options
+ * @returns Complete sitemap data
+ */
+declare function generateSitemap(site: PublishedSite, articles: readonly PublishedArticle[], authors?: readonly PublishedAuthor[], options?: SitemapOptions): SitemapData;
+/**
+ * Converts sitemap data to XML format.
+ *
+ * @param sitemapData - The sitemap data to convert
+ * @returns XML string in sitemap format
+ *
+ * @example
+ * ```typescript
+ * const sitemap = generateSitemap(site, articles);
+ * const xmlString = sitemapToXml(sitemap);
+ * // Use in API route response
+ * ```
+ */
+declare function sitemapToXml(sitemapData: SitemapData): string;
+/**
+ * Generates a sitemap index for large blogs that need multiple sitemaps.
+ *
+ * @param sitemaps - Array of sitemap information
+ * @param baseUrl - Base URL for the site
+ * @returns XML string for sitemap index
+ *
+ * @example
+ * ```typescript
+ * const sitemapIndex = generateSitemapIndex([
+ *   { url: 'https://example.com/sitemap-articles.xml', lastmod: '2023-01-01T00:00:00Z' },
+ *   { url: 'https://example.com/sitemap-authors.xml', lastmod: '2023-01-01T00:00:00Z' }
+ * ], 'https://example.com');
+ * ```
+ */
+declare function generateSitemapIndex(sitemaps: readonly {
+    url: string;
+    lastmod?: string;
+}[], _baseUrl: string): string;
+/**
+ * Validates sitemap data for compliance with search engine guidelines.
+ *
+ * @param sitemapData - The sitemap data to validate
+ * @returns Validation results with errors and warnings
+ *
+ * @example
+ * ```typescript
+ * const sitemap = generateSitemap(site, articles);
+ * const validation = validateSitemap(sitemap);
+ *
+ * if (validation.errors.length > 0) {
+ *   console.error('Sitemap errors:', validation.errors);
+ * }
+ * ```
+ */
+declare function validateSitemap(sitemapData: SitemapData): {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+};
+/**
+ * Creates a separate sitemap specifically for blog content.
+ * Useful for large sites that need to split sitemaps by content type.
+ *
+ * @param site - The published site information
+ * @param articles - Array of published articles
+ * @param authors - Array of published authors (optional)
+ * @param options - Sitemap generation options
+ * @returns Next.js sitemap function
+ *
+ * @example
+ * ```typescript
+ * // app/blog-sitemap/route.ts - separate blog sitemap endpoint
+ * import { createBlogSitemapRoute } from '@xexr/blog-platform';
+ *
+ * export const GET = createBlogSitemapRoute(site, articles, authors, {
+ *   includeAuthorPages: true,
+ *   articlesPerPage: 20
+ * });
+ * ```
+ */
+declare function createBlogSitemapRoute(site: PublishedSite, articles: readonly PublishedArticle[], authors?: readonly PublishedAuthor[], options?: SitemapOptions): () => Promise<Response>;
+/**
+ * Configuration interface for blog data fetching.
+ * Used to fetch blog data for sitemap generation.
+ */
+interface BlogSitemapConfig {
+    /** Function to fetch site data */
+    getSite: () => Promise<PublishedSite>;
+    /** Function to fetch published articles */
+    getArticles: () => Promise<readonly PublishedArticle[]>;
+    /** Function to fetch authors (optional) */
+    getAuthors?: () => Promise<readonly PublishedAuthor[]>;
+    /** Sitemap generation options */
+    options?: SitemapOptions;
+}
+/**
+ * Higher-order function that creates a Next.js sitemap function with data fetching.
+ * Ideal for dynamic blog content that needs to be fetched at sitemap generation time.
+ *
+ * @param config - Configuration for fetching blog data
+ * @returns Next.js sitemap function
+ *
+ * @example
+ * ```typescript
+ * // app/sitemap.ts
+ * import { createDynamicBlogSitemap } from '@xexr/blog-platform';
+ * import { getBlogData } from './lib/blog';
+ *
+ * export default createDynamicBlogSitemap({
+ *   getSite: () => getBlogData().site,
+ *   getArticles: () => getBlogData().articles,
+ *   getAuthors: () => getBlogData().authors,
+ *   options: {
+ *     includeAuthorPages: true,
+ *     changeFrequency: { articles: 'weekly' }
+ *   }
+ * });
+ * ```
+ */
+declare function createDynamicBlogSitemap(config: BlogSitemapConfig): () => Promise<NextjsSitemapEntry[]>;
+
+/**
+ * Structured Data (JSON-LD) utilities for SEO optimization
+ *
+ * This module provides comprehensive schema.org structured data generation
+ * for blog articles, authors, and organizations. It follows Google's
+ * recommended guidelines for structured data markup.
+ *
+ * @see https://developers.google.com/search/docs/appearance/structured-data
+ * @see https://schema.org/
+ */
+
+/**
+ * Base schema.org context and type
+ */
+interface BaseStructuredData {
+    "@context": "https://schema.org";
+    "@type": string;
+    "@id"?: string;
+}
+/**
+ * Person schema for authors
+ * @see https://schema.org/Person
+ */
+interface PersonSchema extends BaseStructuredData {
+    "@type": "Person";
+    name: string;
+    description?: string;
+    identifier?: string;
+    url?: string;
+    sameAs?: string[];
+    jobTitle?: string;
+    affiliation?: OrganizationSchema;
+    knowsAbout?: string[];
+    additionalType?: string;
+}
+/**
+ * Organization schema for blog sites
+ * @see https://schema.org/Organization
+ */
+interface OrganizationSchema extends BaseStructuredData {
+    "@type": "Organization";
+    name: string;
+    description?: string;
+    url?: string;
+    logo?: string;
+    sameAs?: string[];
+    foundingDate?: string;
+    location?: string;
+    contactPoint?: {
+        "@type": "ContactPoint";
+        contactType: string;
+        url?: string;
+        email?: string;
+    };
+}
+/**
+ * BlogPosting schema for articles
+ * @see https://schema.org/BlogPosting
+ */
+interface BlogPostingSchema extends BaseStructuredData {
+    "@type": "BlogPosting";
+    headline: string;
+    description?: string;
+    image?: string | string[];
+    datePublished: string;
+    dateModified?: string;
+    author?: PersonSchema | PersonSchema[];
+    publisher: OrganizationSchema;
+    mainEntityOfPage: {
+        "@type": "WebPage";
+        "@id": string;
+    };
+    keywords?: string | string[];
+    wordCount?: number;
+    timeRequired?: string;
+    inLanguage?: string;
+    isAccessibleForFree?: boolean;
+    genre?: string | string[];
+    about?: {
+        "@type": "Thing";
+        name: string;
+    }[];
+    mentions?: {
+        "@type": "Thing";
+        name: string;
+    }[];
+}
+/**
+ * WebSite schema for the blog home page
+ * @see https://schema.org/WebSite
+ */
+interface WebSiteSchema extends BaseStructuredData {
+    "@type": "WebSite";
+    name: string;
+    description?: string;
+    url: string;
+    publisher: OrganizationSchema;
+    inLanguage?: string;
+    potentialAction?: {
+        "@type": "SearchAction";
+        target: {
+            "@type": "EntryPoint";
+            urlTemplate: string;
+        };
+        "query-input": string;
+    };
+}
+/**
+ * BreadcrumbList schema for navigation
+ * @see https://schema.org/BreadcrumbList
+ */
+interface BreadcrumbListSchema extends BaseStructuredData {
+    "@type": "BreadcrumbList";
+    itemListElement: {
+        "@type": "ListItem";
+        position: number;
+        name: string;
+        item: string;
+    }[];
+}
+/**
+ * Options for customizing structured data generation
+ */
+interface StructuredDataOptions {
+    /** Include optional properties like keywords, mentions, etc. */
+    includeOptionalProperties?: boolean;
+    /** Include search action in WebSite schema */
+    includeSearchAction?: boolean;
+    /** Custom domain override for URLs */
+    customDomain?: string;
+    /** Path prefix for blog URLs (e.g., '/blog', '/articles') */
+    pathPrefix?: string;
+    /** Language code (e.g., 'en-US') */
+    language?: string;
+    /** Whether content is free to access */
+    isAccessibleForFree?: boolean;
+}
+/**
+ * Generate comprehensive structured data for a blog article
+ */
+declare function generateArticleStructuredData(article: PublishedArticle, options?: StructuredDataOptions): BlogPostingSchema;
+/**
+ * Generate structured data for an author
+ */
+declare function generateAuthorStructuredData(author: PublishedAuthor, options?: StructuredDataOptions): PersonSchema;
+/**
+ * Generate structured data for a blog site organization
+ */
+declare function generateOrganizationStructuredData(site: PublishedSite, options?: StructuredDataOptions): OrganizationSchema;
+/**
+ * Generate structured data for the blog website
+ */
+declare function generateWebSiteStructuredData(site: PublishedSite, options?: StructuredDataOptions): WebSiteSchema;
+/**
+ * Generate breadcrumb structured data for navigation
+ */
+declare function generateBreadcrumbStructuredData(breadcrumbs: Array<{
+    name: string;
+    url: string;
+}>, options?: StructuredDataOptions): BreadcrumbListSchema;
+/**
+ * Generate combined structured data for a complete article page
+ */
+declare function generateCompleteArticleStructuredData(article: PublishedArticle, options?: StructuredDataOptions): Array<BlogPostingSchema | WebSiteSchema | BreadcrumbListSchema>;
+/**
+ * Generate structured data for the blog home page
+ */
+declare function generateBlogHomeStructuredData(site: PublishedSite, featuredArticles?: PublishedArticle[], options?: StructuredDataOptions): Array<WebSiteSchema | BlogPostingSchema>;
+/**
+ * Validate structured data schema
+ */
+declare function validateStructuredData(schema: BaseStructuredData): {
+    isValid: boolean;
+    errors: string[];
+};
+/**
+ * Convert structured data to JSON-LD string for HTML embedding
+ */
+declare function structuredDataToJsonLd(schema: BaseStructuredData | BaseStructuredData[]): string;
+/**
+ * Create a React script element for JSON-LD structured data
+ */
+declare function createStructuredDataScript(schema: BaseStructuredData | BaseStructuredData[]): {
+    type: string;
+    dangerouslySetInnerHTML: {
+        __html: string;
+    };
+};
+/**
+ * Extract keywords from article content for structured data
+ */
+declare function extractKeywordsFromArticle(article: PublishedArticle): string[];
+/**
+ * Error types for structured data operations
+ */
+declare class StructuredDataError extends Error {
+    readonly code: string;
+    readonly details?: unknown | undefined;
+    constructor(message: string, code: string, details?: unknown | undefined);
+}
+/**
+ * Generate structured data with error handling
+ */
+declare function safeGenerateArticleStructuredData(article: PublishedArticle, options?: StructuredDataOptions): {
+    schema?: BlogPostingSchema;
+    error?: StructuredDataError;
+};
+
+/**
+ * POST /api/blog/publish
+ *
+ * Publishes an article to the blog platform with full idempotency support.
+ * This endpoint receives content from Bloggy core and stores it for rendering.
+ *
+ * Request body should contain a PublishPayload with:
+ * - article: The complete article data
+ * - idempotencyKey: SHA-256 hash for duplicate prevention
+ * - Optional overrides for slug, meta description, etc.
+ */
+declare function POST$1(request: NextRequest): Promise<NextResponse<PublishResult>>;
+
+/**
+ * POST /api/blog/unpublish
+ *
+ * Unpublishes an article from the blog platform with full idempotency support.
+ * This endpoint receives unpublish requests from Bloggy core and removes the content.
+ *
+ * Request body should contain an UnpublishPayload with:
+ * - slug: The article slug to unpublish
+ * - idempotencyKey: SHA-256 hash for duplicate prevention
+ * - Optional dry run flag for validation
+ */
+declare function POST(request: NextRequest): Promise<NextResponse<PublishResult>>;
+
+/**
+ * Version information
+ */
+interface VersionInfo {
+    name: string;
+    version: string;
+    major: number;
+    minor: number;
+    patch: number;
+}
+/**
+ * Version compatibility result
+ */
+interface VersionCompatibilityResult {
+    compatible: boolean;
+    errorCode?: string;
+    errorMessage?: string;
+    warning?: string;
+}
+
+/**
+ * Version compatibility response
+ */
+interface VersionResponse {
+    success: boolean;
+    versions: {
+        bloggy: VersionInfo;
+        platform: VersionInfo;
+    };
+    compatibility: VersionCompatibilityResult;
+    error?: string;
+}
+/**
+ * GET /api/blog/version
+ *
+ * Returns version information and compatibility status for Bloggy core and blog platform.
+ * Used by customers to verify compatibility before publishing.
+ *
+ * Optional X-Bloggy-Version header can be provided to check compatibility
+ * with specific versions.
+ */
+declare function GET$1(request: NextRequest): Promise<NextResponse<VersionResponse>>;
+
+/**
+ * GET /api/blog/slugs/{slug}
+ *
+ * Checks if a slug is already in use on the blog platform.
+ * Used for dry-run validation in publishing workflow.
+ *
+ * Returns: { exists: boolean, message?: string }
+ * - exists: false -> available
+ * - exists: true -> taken, with suggestion message
+ */
+declare function GET(request: NextRequest, { params }: {
+    params: Promise<{
+        slug: string;
+    }>;
+}): Promise<NextResponse>;
+/**
+ * OPTIONS /api/blog/slugs/{slug}
+ * Handle CORS preflight
+ */
+declare function OPTIONS(request: NextRequest): Promise<NextResponse>;
+
+/**
+ * @xexr/blog-platform
+ *
+ * SEO-friendly blog platform for Next.js with Bloggy integration.
+ * Enables publishing AI-generated content to custom domains.
+ */
+
+declare const PACKAGE_VERSION: string;
+
+export { ApiKeyAuth, type AuthConfig, type AuthResult, ArticlePage as BlogArticlePage, BlogHomePage, type BlogPlatformConfig, type BlogPlatformStorage, type BlogPostingSchema, type BlogSitemapConfig, type BreadcrumbListSchema, Button, type CanonicalUrlOptions, Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle, DrizzleStorage, EnvAuth, type GeneratedMetadata, InMemoryStorage, type LinkTag, type MetaTag, type MetadataOptions, type NextjsSitemapEntry, NoAuth, type OrganizationSchema, PACKAGE_VERSION, Pagination$1 as Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, type PersonSchema, PublishResult, PublishedArticle, PublishedAuthor, PublishedSite, type RateLimitConfig, type RateLimitResult, Pagination as ShadcnPagination, type SitemapChangeFreq, type SitemapData, type SitemapEntry, type SitemapOptions, StructuredDataError, type StructuredDataOptions, UninitializedAuth, type WebSiteSchema, autoConfigureRateLimit, bpArticles, bpOperations, buttonVariants, checkRateLimit, cn, configureRateLimit, createBlogSitemapRoute, createDynamicBlogSitemap, createRateLimitErrorResponse, createStructuredDataScript, enforceRateLimit, extractKeywordsFromArticle, extractTokenFromHeader, generateArticleMetadata, generateArticleStructuredData, generateAuthorStructuredData, generateBlogHomeMetadata, generateBlogHomeStructuredData, generateBlogSitemapEntries, generateBreadcrumbStructuredData, generateCanonicalUrl, generateCanonicalUrlFromSlug, generateCompleteArticleStructuredData, generateOrganizationStructuredData, generatePaginationMetadata, generateSiteMetadata, generateSitemap, generateSitemapIndex, generateWebSiteStructuredData, getAuthConfig, getBaseUrl, getDrizzleAdapterSql, getRateLimitHeaders, getStorage, initBlogPlatform, initBlogPlatformDev, initBlogPlatformOnce, initBlogPlatformProd, initEnvAuth, isValidCanonicalUrl, metadataToHtml, normalizeDomain, normalizeSlug, POST$1 as publishHandler, safeGenerateArticleStructuredData, setAuthConfig, setStorage, shouldSkipAuth, sitemapToXml, GET as slugExistsHandler, OPTIONS as slugExistsOptionsHandler, structuredDataToJsonLd, POST as unpublishHandler, updateArticleCanonicalUrl, usePagination, validateMetadata, validateSitemap, validateStructuredData, GET$1 as versionHandler };