@zoyth/simple-site-framework 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2184 @@
+import { ThemeConfig, HeroContent, LocalizedString, AboutContent, ServicesContent, HeaderConfig, FooterConfig } from './config/index.js';
+export { FooterSection, LogoConfig, NavDropdown, NavDropdownItem, NavItem, NavLink, NavigationConfig, ScriptsConfig, ServiceItem, SiteContent, SiteMetadata, WhyChooseUsContent } from './config/index.js';
+import { NextRequest, NextResponse } from 'next/server';
+import { ClassValue } from 'clsx';
+import { Metadata } from 'next';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode, ButtonHTMLAttributes, HTMLAttributes, InputHTMLAttributes, TextareaHTMLAttributes, ComponentType } from 'react';
+import { LucideProps } from 'lucide-react';
+import { FieldError } from 'react-hook-form';
+
+declare function generateThemeCSS(theme: ThemeConfig): string;
+declare function generateDesignTokens(theme: ThemeConfig): string;
+
+/**
+ * Gets the font import configuration for Next.js
+ * This prepares the data needed to dynamically import fonts
+ */
+declare function getFontConfig(theme: ThemeConfig): {
+    heading: {
+        family: string;
+        weights: string[];
+        variable: string;
+    };
+    body: {
+        family: string;
+        weights: string[];
+        variable: string;
+    };
+};
+/**
+ * Generates CSS variable names from theme fonts
+ */
+declare function getFontVariables(theme: ThemeConfig): string;
+
+/**
+ * Helper to get localized string from content
+ */
+declare function getLocalizedString(localizedString: {
+    [locale: string]: string;
+}, locale: string): string;
+
+interface PolicyMetadata {
+    /** Policy title */
+    title: string;
+    /** Last updated date (ISO string) */
+    lastUpdated: string;
+    /** Optional description for SEO */
+    description?: string;
+    /** Additional custom fields */
+    [key: string]: string | undefined;
+}
+interface Policy {
+    /** Compiled MDX content */
+    content: JSX.Element;
+    /** Frontmatter metadata */
+    metadata: PolicyMetadata;
+    /** Policy slug (filename without locale/extension) */
+    slug: string;
+    /** Locale */
+    locale: string;
+}
+/**
+ * Load a policy markdown file and compile it to React
+ *
+ * @param slug - Policy slug (e.g., 'privacy-policy', 'terms-of-service')
+ * @param locale - Locale code (e.g., 'en', 'fr')
+ * @param contentDir - Directory containing policy files @default 'src/content/policies'
+ * @returns Compiled policy with content and metadata
+ *
+ * @example
+ * ```typescript
+ * const { content, metadata } = await loadPolicy('privacy-policy', 'en');
+ *
+ * return (
+ *   <PolicyLayout
+ *     title={metadata.title}
+ *     lastUpdated={metadata.lastUpdated}
+ *   >
+ *     {content}
+ *   </PolicyLayout>
+ * );
+ * ```
+ */
+declare function loadPolicy(slug: string, locale: string, contentDir?: string): Promise<Policy>;
+/**
+ * Get all unique policy slugs (without locale suffix)
+ *
+ * @param contentDir - Directory containing policy files @default 'src/content/policies'
+ * @returns Array of policy slugs
+ *
+ * @example
+ * ```typescript
+ * const slugs = getPolicySlugs(); // ['privacy-policy', 'terms-of-service']
+ * ```
+ */
+declare function getPolicySlugs(contentDir?: string): string[];
+/**
+ * Get all policies for a specific locale with their metadata
+ *
+ * @param locale - Locale code
+ * @param contentDir - Directory containing policy files @default 'src/content/policies'
+ * @returns Array of policies with metadata
+ *
+ * @example
+ * ```typescript
+ * const policies = await getAllPolicies('en');
+ *
+ * // Render policy list
+ * policies.map(policy => (
+ *   <Link key={policy.slug} href={`/policies/${policy.slug}`}>
+ *     {policy.metadata.title}
+ *   </Link>
+ * ));
+ * ```
+ */
+declare function getAllPolicies(locale: string, contentDir?: string): Promise<Omit<Policy, 'content'>[]>;
+/**
+ * Get available locales for a specific policy
+ *
+ * @param slug - Policy slug
+ * @param contentDir - Directory containing policy files @default 'src/content/policies'
+ * @returns Array of locale codes
+ *
+ * @example
+ * ```typescript
+ * const locales = getPolicyLocales('privacy-policy'); // ['en', 'fr']
+ * ```
+ */
+declare function getPolicyLocales(slug: string, contentDir?: string): string[];
+
+/**
+ * Helper to get localized string from navigation
+ */
+declare function getNavigationString(localizedString: {
+    [locale: string]: string;
+}, locale: string): string;
+/**
+ * Helper to replace placeholders in strings
+ */
+declare function replaceVariables(text: string, variables: Record<string, string>): string;
+
+/**
+ * Locale prefix mode determines how locale appears in URLs
+ *
+ * - 'always': All routes have locale prefix (/en/about, /fr/about)
+ * - 'as-needed': Only non-default locales have prefix (/about, /fr/about)
+ * - 'never': No locale prefixes, detection via cookie/header only
+ */
+type LocalePrefix = 'always' | 'as-needed' | 'never';
+/**
+ * Cookie configuration for locale persistence
+ */
+interface LocaleCookieConfig {
+    /** Cookie name @default 'NEXT_LOCALE' */
+    name?: string;
+    /** Cookie max age in seconds @default 31536000 (1 year) */
+    maxAge?: number;
+    /** Cookie SameSite attribute @default 'lax' */
+    sameSite?: 'lax' | 'strict' | 'none';
+}
+/**
+ * Slug translations mapping for bilingual/multilingual routes
+ * Maps slugs from one locale to another
+ *
+ * @example
+ * {
+ *   fr: {
+ *     '/a-propos': '/about',
+ *     '/nous-contacter': '/contact'
+ *   },
+ *   en: {
+ *     '/about': '/a-propos',
+ *     '/contact': '/nous-contacter'
+ *   }
+ * }
+ */
+interface SlugTranslations {
+    [locale: string]: {
+        [slug: string]: string;
+    };
+}
+/**
+ * Complete i18n configuration for a project
+ *
+ * @example
+ * ```typescript
+ * export const i18nConfig: I18nConfig = {
+ *   locales: ['en', 'fr', 'es'],
+ *   defaultLocale: 'en',
+ *   localePrefix: 'as-needed',
+ *   localeDetection: true,
+ *   localeNames: {
+ *     en: 'English',
+ *     fr: 'Français',
+ *     es: 'Español'
+ *   }
+ * };
+ * ```
+ */
+interface I18nConfig {
+    /**
+     * Array of supported locale codes (ISO 639-1)
+     * @example ['en', 'fr', 'es', 'de', 'ja']
+     */
+    locales: readonly string[];
+    /**
+     * Default locale to use when none is specified
+     * Must be one of the locales in the locales array
+     */
+    defaultLocale: string;
+    /**
+     * Locale prefix mode for URL routing
+     * @default 'as-needed'
+     */
+    localePrefix?: LocalePrefix;
+    /**
+     * Enable automatic locale detection from browser headers
+     * @default true
+     */
+    localeDetection?: boolean;
+    /**
+     * Full locale names for display in UI
+     * @example { en: 'English', fr: 'Français' }
+     */
+    localeNames?: Record<string, string>;
+    /**
+     * Short locale labels for compact display (e.g., language selector)
+     * @example { en: 'EN', fr: 'FR' }
+     */
+    localeLabels?: Record<string, string>;
+    /**
+     * Locales that use right-to-left text direction
+     * @example ['ar', 'he', 'fa']
+     */
+    rtlLocales?: readonly string[];
+    /**
+     * Cookie configuration for locale persistence
+     */
+    localeCookie?: LocaleCookieConfig;
+    /**
+     * Custom slug translations for multilingual routes
+     * If not provided, no slug translation will occur
+     */
+    slugTranslations?: SlugTranslations;
+}
+/**
+ * Type guard to validate locale string
+ */
+type ValidLocale<T extends I18nConfig> = T['locales'][number];
+/**
+ * Browser language preference with quality value (from Accept-Language header)
+ */
+interface LanguagePreference {
+    locale: string;
+    quality: number;
+}
+
+/**
+ * Initialize the i18n configuration
+ * Must be called before using any i18n features
+ *
+ * @param config - Complete i18n configuration
+ *
+ * @example
+ * ```typescript
+ * import { setI18nConfig } from 'simple-site-framework/lib/i18n';
+ * import { i18nConfig } from './config/i18n';
+ *
+ * setI18nConfig(i18nConfig);
+ * ```
+ */
+declare function setI18nConfig(config: I18nConfig): void;
+/**
+ * Get the current i18n configuration
+ * Returns legacy default config if not initialized (for build compatibility)
+ *
+ * @deprecated Calling without initialization - will throw in v1.0.0
+ */
+declare function getI18nConfig(): I18nConfig;
+/**
+ * Check if i18n config has been initialized
+ */
+declare function isI18nConfigInitialized(): boolean;
+/**
+ * Get supported locales array
+ */
+declare function getLocales(): readonly string[];
+/**
+ * Get default locale
+ */
+declare function getDefaultLocale(): string;
+/**
+ * Get locale prefix mode
+ */
+declare function getLocalePrefix(): LocalePrefix;
+/**
+ * Get locale names mapping
+ */
+declare function getLocaleNames(): Record<string, string>;
+/**
+ * Get locale labels mapping
+ */
+declare function getLocaleLabels(): Record<string, string>;
+/**
+ * Get RTL locales array
+ */
+declare function getRtlLocales(): readonly string[];
+/**
+ * Check if locale detection is enabled
+ */
+declare function isLocaleDetectionEnabled(): boolean;
+/**
+ * Get locale cookie configuration
+ */
+declare function getLocaleCookieConfig(): {
+    name: string;
+    maxAge: number;
+    sameSite: "none" | "lax" | "strict";
+};
+/**
+ * Check if a locale is supported
+ */
+declare function isSupportedLocale(locale: string): boolean;
+/**
+ * Get full locale name for display
+ */
+declare function getLocaleName(locale: string): string;
+/**
+ * Get short locale label for compact display
+ */
+declare function getLocaleLabel(locale: string): string;
+/**
+ * @deprecated Use getLocales() instead. This export will be removed in v1.0.0
+ */
+declare const locales: readonly ["fr", "en"];
+/**
+ * @deprecated Import from config schemas instead
+ */
+type Locale = 'fr' | 'en';
+/**
+ * @deprecated Use getDefaultLocale() instead. This export will be removed in v1.0.0
+ */
+declare const defaultLocale: Locale;
+
+declare const LOCALE_COOKIE_NAME = "NEXT_LOCALE";
+/**
+ * Get locale from cookie
+ * Returns null if cookie not found or locale not supported
+ */
+declare function getLocaleFromCookie(): string | null;
+/**
+ * Set locale cookie
+ * Uses configuration from i18n config
+ */
+declare function setLocaleCookie(locale: string): void;
+
+declare const defaultSlugTranslations: SlugTranslations;
+/**
+ * Translates a path from one locale to another
+ *
+ * Merges translations in this priority order:
+ * 1. Custom translations passed as parameter (highest priority)
+ * 2. Translations from i18n config (if configured)
+ * 3. Default translations (lowest priority)
+ *
+ * @param path - The current path (without locale prefix)
+ * @param fromLocale - The current locale
+ * @param toLocale - The target locale
+ * @param customTranslations - Optional custom translations to merge with defaults
+ * @returns The translated path
+ *
+ * @example
+ * ```typescript
+ * // With config translations
+ * translateSlug('/about', 'en', 'fr')
+ * // Returns: '/a-propos' (from config or defaults)
+ *
+ * // With custom override
+ * translateSlug('/about', 'en', 'fr', {
+ *   en: { '/about': '/notre-equipe' }
+ * })
+ * // Returns: '/notre-equipe' (custom override)
+ *
+ * // Nested paths
+ * translateSlug('/about/team', 'en', 'fr')
+ * // Returns: '/a-propos/team' (translates base, keeps rest)
+ * ```
+ */
+declare function translateSlug(path: string, fromLocale: string, toLocale: string, customTranslations?: SlugTranslations): string;
+
+/**
+ * Format a date according to locale
+ *
+ * @param date - Date to format
+ * @param locale - Locale code (e.g., 'en', 'fr', 'es')
+ * @param options - Intl.DateTimeFormat options
+ *
+ * @example
+ * ```typescript
+ * formatDate(new Date('2026-02-01'), 'fr', { dateStyle: 'long' })
+ * // "1 février 2026"
+ *
+ * formatDate(new Date('2026-02-01'), 'en', { dateStyle: 'long' })
+ * // "February 1, 2026"
+ *
+ * formatDate(new Date(), 'fr', {
+ *   weekday: 'long',
+ *   year: 'numeric',
+ *   month: 'long',
+ *   day: 'numeric'
+ * })
+ * // "samedi 1 février 2026"
+ * ```
+ */
+declare function formatDate(date: Date, locale: string, options?: Intl.DateTimeFormatOptions): string;
+/**
+ * Format a number according to locale
+ *
+ * @param value - Number to format
+ * @param locale - Locale code
+ * @param options - Intl.NumberFormat options
+ *
+ * @example
+ * ```typescript
+ * formatNumber(1234567.89, 'en')
+ * // "1,234,567.89"
+ *
+ * formatNumber(1234567.89, 'fr')
+ * // "1 234 567,89"
+ *
+ * formatNumber(0.42, 'en', { style: 'percent' })
+ * // "42%"
+ *
+ * formatNumber(1234, 'en', { minimumFractionDigits: 2 })
+ * // "1,234.00"
+ * ```
+ */
+declare function formatNumber(value: number, locale: string, options?: Intl.NumberFormatOptions): string;
+/**
+ * Format a currency amount according to locale
+ *
+ * @param amount - Amount to format
+ * @param locale - Locale code
+ * @param currency - ISO 4217 currency code (e.g., 'USD', 'EUR', 'CAD')
+ * @param options - Additional Intl.NumberFormat options
+ *
+ * @example
+ * ```typescript
+ * formatCurrency(1299.99, 'en', 'USD')
+ * // "$1,299.99"
+ *
+ * formatCurrency(1299.99, 'fr', 'EUR')
+ * // "1 299,99 €"
+ *
+ * formatCurrency(1299.99, 'fr-CA', 'CAD')
+ * // "1 299,99 $"
+ *
+ * formatCurrency(1299.99, 'ja', 'JPY')
+ * // "¥1,300"
+ *
+ * formatCurrency(0.99, 'en', 'USD', { currencyDisplay: 'name' })
+ * // "0.99 US dollars"
+ * ```
+ */
+declare function formatCurrency(amount: number, locale: string, currency: string, options?: Intl.NumberFormatOptions): string;
+/**
+ * Format relative time (e.g., "2 hours ago", "in 3 days")
+ *
+ * @param value - Numeric value (negative for past, positive for future)
+ * @param unit - Time unit
+ * @param locale - Locale code
+ * @param options - Intl.RelativeTimeFormat options
+ *
+ * @example
+ * ```typescript
+ * formatRelativeTime(-2, 'hour', 'en')
+ * // "2 hours ago"
+ *
+ * formatRelativeTime(-2, 'hour', 'fr')
+ * // "il y a 2 heures"
+ *
+ * formatRelativeTime(3, 'day', 'en')
+ * // "in 3 days"
+ *
+ * formatRelativeTime(-1, 'week', 'es')
+ * // "hace 1 semana"
+ *
+ * formatRelativeTime(-5, 'minute', 'en', { numeric: 'auto' })
+ * // "5 minutes ago"
+ * ```
+ */
+declare function formatRelativeTime(value: number, unit: Intl.RelativeTimeFormatUnit, locale: string, options?: Intl.RelativeTimeFormatOptions): string;
+/**
+ * Format a date range according to locale
+ * Note: formatRange requires newer TypeScript/Node versions
+ *
+ * @param startDate - Start date
+ * @param endDate - End date
+ * @param locale - Locale code
+ * @param options - Intl.DateTimeFormat options
+ *
+ * @example
+ * ```typescript
+ * formatDateRange(
+ *   new Date('2026-02-01'),
+ *   new Date('2026-02-15'),
+ *   'en',
+ *   { month: 'long', day: 'numeric' }
+ * )
+ * // "February 1 – 15"
+ * ```
+ */
+declare function formatDateRange(startDate: Date, endDate: Date, locale: string, options?: Intl.DateTimeFormatOptions): string;
+/**
+ * Format a list of items according to locale
+ * Falls back to simple comma-separated list if Intl.ListFormat not available
+ *
+ * @param items - Array of items to format
+ * @param locale - Locale code
+ *
+ * @example
+ * ```typescript
+ * formatList(['apples', 'oranges', 'bananas'], 'en')
+ * // "apples, oranges, and bananas"
+ *
+ * formatList(['pommes', 'oranges', 'bananes'], 'fr')
+ * // "pommes, oranges et bananes"
+ * ```
+ */
+declare function formatList(items: string[], locale: string): string;
+/**
+ * Format file size in bytes to human-readable format
+ * Not using Intl, but useful for internationalized apps
+ *
+ * @param bytes - File size in bytes
+ * @param locale - Locale code
+ * @param decimals - Number of decimal places @default 2
+ *
+ * @example
+ * ```typescript
+ * formatFileSize(1024, 'en')
+ * // "1.00 KB"
+ *
+ * formatFileSize(1048576, 'fr')
+ * // "1,00 Mo"
+ *
+ * formatFileSize(1073741824, 'en', 1)
+ * // "1.0 GB"
+ * ```
+ */
+declare function formatFileSize(bytes: number, locale: string, decimals?: number): string;
+/**
+ * Get relative time from a date (auto-selects best unit)
+ *
+ * @param date - Date to compare against now
+ * @param locale - Locale code
+ * @param options - Intl.RelativeTimeFormat options
+ *
+ * @example
+ * ```typescript
+ * // If date is 2 hours ago
+ * getRelativeTime(pastDate, 'en')
+ * // "2 hours ago"
+ *
+ * // If date is 3 days from now
+ * getRelativeTime(futureDate, 'en')
+ * // "in 3 days"
+ *
+ * // If date is 45 seconds ago
+ * getRelativeTime(recentDate, 'fr')
+ * // "il y a 45 secondes"
+ * ```
+ */
+declare function getRelativeTime(date: Date, locale: string, options?: Intl.RelativeTimeFormatOptions): string;
+
+/**
+ * Create Next.js middleware for i18n routing
+ *
+ * @param config - i18n configuration
+ * @returns Middleware function
+ *
+ * @example
+ * ```typescript
+ * // middleware.ts
+ * import { createI18nMiddleware } from 'simple-site-framework/lib/i18n';
+ * import { i18nConfig } from './src/config/i18n';
+ *
+ * export default createI18nMiddleware(i18nConfig);
+ *
+ * export const config = {
+ *   matcher: ['/((?!api|_next/static|_next/image|favicon.ico).*)'],
+ * };
+ * ```
+ */
+declare function createI18nMiddleware(config: I18nConfig): (request: NextRequest) => NextResponse;
+
+/**
+ * Check if a locale uses right-to-left text direction
+ *
+ * @param locale - Locale code to check
+ * @returns true if locale is RTL, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isRtlLocale('ar') // true (Arabic)
+ * isRtlLocale('he') // true (Hebrew)
+ * isRtlLocale('en') // false (English)
+ * isRtlLocale('fr') // false (French)
+ * ```
+ */
+declare function isRtlLocale(locale: string): boolean;
+/**
+ * Get text direction for a locale
+ *
+ * @param locale - Locale code
+ * @returns 'rtl' for right-to-left locales, 'ltr' for left-to-right
+ *
+ * @example
+ * ```tsx
+ * // In layout
+ * <html lang={locale} dir={getTextDirection(locale)}>
+ *
+ * // Results:
+ * getTextDirection('ar') // 'rtl'
+ * getTextDirection('en') // 'ltr'
+ * ```
+ */
+declare function getTextDirection(locale: string): 'ltr' | 'rtl';
+/**
+ * Validate if a locale is supported
+ *
+ * @param locale - Locale code to validate
+ * @returns true if locale is supported, false otherwise
+ *
+ * @example
+ * ```typescript
+ * // With config: locales: ['en', 'fr', 'es']
+ * validateLocale('en') // true
+ * validateLocale('fr') // true
+ * validateLocale('de') // false
+ * validateLocale('invalid') // false
+ * ```
+ */
+declare function validateLocale(locale: string): boolean;
+/**
+ * Get all supported locales except the current one
+ *
+ * @param currentLocale - Current locale to exclude
+ * @returns Array of alternate locales
+ *
+ * @example
+ * ```typescript
+ * // With config: locales: ['en', 'fr', 'es', 'de']
+ * getAlternateLocales('en') // ['fr', 'es', 'de']
+ * getAlternateLocales('fr') // ['en', 'es', 'de']
+ * ```
+ */
+declare function getAlternateLocales(currentLocale: string): string[];
+/**
+ * Normalize locale code to lowercase
+ * Handles variants like 'en-US' -> 'en', 'zh-CN' -> 'zh'
+ *
+ * @param locale - Locale code (can include region)
+ * @returns Normalized locale code
+ *
+ * @example
+ * ```typescript
+ * normalizeLocale('en-US') // 'en'
+ * normalizeLocale('zh-CN') // 'zh'
+ * normalizeLocale('FR')    // 'fr'
+ * normalizeLocale('es')    // 'es'
+ * ```
+ */
+declare function normalizeLocale(locale: string): string;
+/**
+ * Check if a locale code matches a supported locale
+ * Handles locale variants (e.g., 'en-US' matches 'en')
+ *
+ * @param locale - Locale code to check (can include region)
+ * @returns Matching supported locale or null
+ *
+ * @example
+ * ```typescript
+ * // With config: locales: ['en', 'fr', 'es']
+ * matchLocale('en-US') // 'en'
+ * matchLocale('fr-CA') // 'fr'
+ * matchLocale('de-DE') // null
+ * ```
+ */
+declare function matchLocale(locale: string): string | null;
+/**
+ * Get locale display name in its own language (autonym)
+ *
+ * @param locale - Locale code
+ * @returns Display name or locale code if not found
+ *
+ * @example
+ * ```typescript
+ * getLocaleAutonym('en') // 'English'
+ * getLocaleAutonym('fr') // 'Français'
+ * getLocaleAutonym('es') // 'Español'
+ * ```
+ */
+declare function getLocaleAutonym(locale: string): string;
+/**
+ * Format locale for display (e.g., for language selector)
+ *
+ * @param locale - Locale code
+ * @param format - Display format
+ * @returns Formatted locale string
+ *
+ * @example
+ * ```typescript
+ * formatLocaleDisplay('en', 'name')  // 'English'
+ * formatLocaleDisplay('fr', 'label') // 'FR'
+ * formatLocaleDisplay('es', 'code')  // 'es'
+ * ```
+ */
+declare function formatLocaleDisplay(locale: string, format?: 'name' | 'label' | 'code'): string;
+
+/**
+ * Combines class names using clsx and merges Tailwind classes intelligently
+ * @param inputs - Class names to combine
+ * @returns Merged class string
+ */
+declare function cn(...inputs: ClassValue[]): string;
+
+type EventCategory = 'cta' | 'form' | 'navigation' | 'engagement' | 'conversion' | 'ab_test';
+type CTAType = 'signup' | 'trial' | 'contact' | 'download' | 'other';
+type FormAction = 'start' | 'submit' | 'error' | 'abandon';
+type PricingAction = 'view' | 'calculate' | 'plan_select' | 'currency_change';
+type FeatureAction = 'view' | 'video_play' | 'video_complete' | 'cta_click';
+type VideoAction = 'play' | 'pause' | 'complete' | '25%' | '50%' | '75%';
+type NavigationLocation = 'header' | 'footer' | 'content' | 'mobile';
+type ConversionType = 'trial_signup' | 'contact' | 'newsletter' | 'other';
+type ScrollDepth = 25 | 50 | 75 | 100;
+interface AnalyticsEvent {
+    event: string;
+    event_category?: EventCategory;
+    event_label?: string;
+    value?: number;
+    [key: string]: unknown;
+}
+interface CTAClickEvent extends AnalyticsEvent {
+    event: 'cta_click';
+    event_category: 'cta';
+    cta_location: string;
+    cta_text: string;
+    cta_type: CTAType;
+}
+interface FormEvent extends AnalyticsEvent {
+    event: `form_${FormAction}`;
+    event_category: 'form';
+    form_name: string;
+    form_action: FormAction;
+}
+interface PricingEvent extends AnalyticsEvent {
+    event: 'pricing_interaction';
+    event_category: 'engagement';
+    pricing_action: PricingAction;
+}
+interface FeatureEvent extends AnalyticsEvent {
+    event: 'feature_engagement';
+    event_category: 'engagement';
+    feature_name: string;
+    feature_action: FeatureAction;
+}
+interface VideoEvent extends AnalyticsEvent {
+    event: 'video_interaction';
+    event_category: 'engagement';
+    video_title: string;
+    video_action: VideoAction;
+}
+interface NavigationEvent extends AnalyticsEvent {
+    event: 'navigation_click';
+    event_category: 'navigation';
+    link_text: string;
+    link_url: string;
+    link_location: NavigationLocation;
+}
+interface ConversionEvent extends AnalyticsEvent {
+    event: 'conversion';
+    event_category: 'conversion';
+    conversion_type: ConversionType;
+}
+interface ABTestEvent extends AnalyticsEvent {
+    event: 'ab_test_event';
+    event_category: 'ab_test';
+    test_id: string;
+    variant: 'A' | 'B';
+    test_event: string;
+}
+interface ScrollDepthEvent extends AnalyticsEvent {
+    event: 'scroll_depth';
+    event_category: 'engagement';
+    scroll_percentage: ScrollDepth;
+    page_path: string;
+}
+interface PageViewEvent extends AnalyticsEvent {
+    event: 'page_view';
+    page_path: string;
+    page_title: string;
+}
+
+declare global {
+    interface Window {
+        dataLayer: unknown[];
+    }
+}
+
+/**
+ * Generic event tracking function
+ * Use this for custom events not covered by specific tracking functions
+ *
+ * @param eventName - Name of the event
+ * @param properties - Additional event properties
+ *
+ * @example
+ * ```typescript
+ * trackEvent('button_click', {
+ *   button_text: 'Sign Up',
+ *   button_location: 'hero',
+ *   button_variant: 'primary'
+ * });
+ * ```
+ */
+declare function trackEvent(eventName: string, properties?: Record<string, unknown>): void;
+/**
+ * Track CTA click events
+ * @param ctaLocation - Where the CTA appears (e.g., 'hero', 'pricing', 'mobile_sticky')
+ * @param ctaText - The text on the CTA button
+ * @param ctaType - Type of CTA (e.g., 'signup', 'trial', 'contact')
+ */
+declare function trackCTAClick(ctaLocation: string, ctaText: string, ctaType?: 'signup' | 'trial' | 'contact' | 'download' | 'other'): void;
+/**
+ * Track form interactions
+ * @param formName - Identifier for the form
+ * @param action - Form action (start, submit, error, abandon)
+ */
+declare function trackFormEvent(formName: string, action: 'start' | 'submit' | 'error' | 'abandon', metadata?: Record<string, unknown>): void;
+/**
+ * Track page view (for SPAs and custom tracking)
+ * @param pagePath - The page path
+ * @param pageTitle - The page title
+ */
+declare function trackPageView(pagePath: string, pageTitle: string): void;
+/**
+ * Track pricing page interactions
+ * @param action - Type of interaction
+ */
+declare function trackPricingEvent(action: 'view' | 'calculate' | 'plan_select' | 'currency_change', metadata?: Record<string, unknown>): void;
+/**
+ * Track feature page engagement
+ * @param featureName - Name of the feature being viewed
+ * @param action - Type of engagement
+ */
+declare function trackFeatureEngagement(featureName: string, action: 'view' | 'video_play' | 'video_complete' | 'cta_click', metadata?: Record<string, unknown>): void;
+/**
+ * Track resource downloads
+ * @param resourceName - Name of the resource
+ * @param resourceType - Type of resource (pdf, video, etc.)
+ */
+declare function trackResourceDownload(resourceName: string, resourceType: string): void;
+/**
+ * Track video interactions
+ * @param videoTitle - Title of the video
+ * @param action - Video action
+ */
+declare function trackVideoEvent(videoTitle: string, action: 'play' | 'pause' | 'complete' | '25%' | '50%' | '75%', metadata?: Record<string, unknown>): void;
+/**
+ * Track navigation events
+ * @param linkText - Text of the link clicked
+ * @param linkUrl - URL of the link
+ * @param linkLocation - Where the link appears (header, footer, content)
+ */
+declare function trackNavigation(linkText: string, linkUrl: string, linkLocation: 'header' | 'footer' | 'content' | 'mobile'): void;
+/**
+ * Track A/B test variant assignment and events
+ * @param testId - ID of the A/B test
+ * @param variant - Variant assigned (A or B)
+ * @param eventName - Name of the event
+ */
+declare function trackABTestEvent(testId: string, variant: 'A' | 'B', eventName: string, metadata?: Record<string, unknown>): void;
+/**
+ * Track conversion events (trial signups, purchases, etc.)
+ * @param conversionType - Type of conversion
+ * @param value - Monetary value (optional)
+ */
+declare function trackConversion(conversionType: 'trial_signup' | 'contact' | 'newsletter' | 'other', value?: number, metadata?: Record<string, unknown>): void;
+/**
+ * Track scroll depth
+ * @param percentage - Scroll depth percentage (25, 50, 75, 100)
+ * @param pagePath - The page path
+ */
+declare function trackScrollDepth(percentage: 25 | 50 | 75 | 100, pagePath: string): void;
+/**
+ * Track search events
+ * @param searchTerm - The search term
+ * @param resultCount - Number of results (optional)
+ */
+declare function trackSearch(searchTerm: string, resultCount?: number): void;
+/**
+ * Track outbound link clicks
+ * @param url - The external URL
+ * @param linkText - Text of the link
+ */
+declare function trackOutboundLink(url: string, linkText: string): void;
+/**
+ * Track error events
+ * @param errorType - Type of error
+ * @param errorMessage - Error message or description
+ */
+declare function trackError(errorType: string, errorMessage: string): void;
+
+/**
+ * Email validation schema
+ * @example
+ * const schema = z.object({ email: emailSchema })
+ */
+declare const emailSchema: any;
+/**
+ * Phone number validation (international format)
+ * Accepts formats: +1234567890, +1 (234) 567-8900, etc.
+ */
+declare const phoneSchema: any;
+/**
+ * US/Canada postal code validation
+ * Accepts: 12345, 12345-6789, A1A 1A1, A1A1A1
+ */
+declare const postalCodeSchema: any;
+/**
+ * Password strength validation
+ * Requires: min 8 chars, 1 uppercase, 1 lowercase, 1 number
+ */
+declare const passwordSchema: any;
+/**
+ * URL validation schema
+ */
+declare const urlSchema: any;
+/**
+ * Credit card number validation (Luhn algorithm)
+ */
+declare const creditCardSchema: any;
+/**
+ * File upload schema with type and size validation
+ * @param acceptedTypes - MIME types (e.g., ['image/jpeg', 'image/png'])
+ * @param maxSizeMB - Maximum file size in megabytes
+ */
+declare function fileSchema(acceptedTypes: string[], maxSizeMB: number): any;
+/**
+ * Image file schema (JPEG, PNG, WebP)
+ * @param maxSizeMB - Maximum file size in megabytes (default: 5)
+ */
+declare function imageSchema(maxSizeMB?: number): any;
+/**
+ * Required string field (non-empty)
+ */
+declare const requiredString: any;
+/**
+ * Optional string field (empty string converted to undefined)
+ */
+declare const optionalString: any;
+/**
+ * Numeric string (e.g., for phone inputs)
+ */
+declare const numericString: any;
+/**
+ * Date string in ISO format
+ */
+declare const dateString: any;
+/**
+ * Checkbox boolean (must be true)
+ * Useful for "I agree to terms" checkboxes
+ */
+declare const mustBeTrue: any;
+
+declare const formErrorMessages: {
+    readonly required: {
+        readonly en: "This field is required";
+        readonly fr: "Ce champ est obligatoire";
+    };
+    readonly email: {
+        readonly en: "Please enter a valid email address";
+        readonly fr: "Veuillez entrer une adresse e-mail valide";
+    };
+    readonly phone: {
+        readonly en: "Please enter a valid phone number";
+        readonly fr: "Veuillez entrer un numéro de téléphone valide";
+    };
+    readonly url: {
+        readonly en: "Please enter a valid URL";
+        readonly fr: "Veuillez entrer une URL valide";
+    };
+    readonly password: {
+        readonly tooShort: {
+            readonly en: "Password must be at least 8 characters";
+            readonly fr: "Le mot de passe doit contenir au moins 8 caractères";
+        };
+        readonly noUppercase: {
+            readonly en: "Password must contain at least one uppercase letter";
+            readonly fr: "Le mot de passe doit contenir au moins une lettre majuscule";
+        };
+        readonly noLowercase: {
+            readonly en: "Password must contain at least one lowercase letter";
+            readonly fr: "Le mot de passe doit contenir au moins une lettre minuscule";
+        };
+        readonly noNumber: {
+            readonly en: "Password must contain at least one number";
+            readonly fr: "Le mot de passe doit contenir au moins un chiffre";
+        };
+    };
+    readonly postalCode: {
+        readonly en: "Invalid postal code";
+        readonly fr: "Code postal invalide";
+    };
+    readonly creditCard: {
+        readonly en: "Invalid credit card number";
+        readonly fr: "Numéro de carte de crédit invalide";
+    };
+    readonly file: {
+        readonly tooLarge: {
+            readonly en: (maxSize: number) => string;
+            readonly fr: (maxSize: number) => string;
+        };
+        readonly invalidType: {
+            readonly en: (types: string[]) => string;
+            readonly fr: (types: string[]) => string;
+        };
+    };
+    readonly mustAccept: {
+        readonly en: "You must accept to continue";
+        readonly fr: "Vous devez accepter pour continuer";
+    };
+    readonly minLength: {
+        readonly en: (min: number) => string;
+        readonly fr: (min: number) => string;
+    };
+    readonly maxLength: {
+        readonly en: (max: number) => string;
+        readonly fr: (max: number) => string;
+    };
+    readonly min: {
+        readonly en: (min: number) => string;
+        readonly fr: (min: number) => string;
+    };
+    readonly max: {
+        readonly en: (max: number) => string;
+        readonly fr: (max: number) => string;
+    };
+    readonly invalidFormat: {
+        readonly en: "Invalid format";
+        readonly fr: "Format invalide";
+    };
+};
+/**
+ * Get localized error message
+ * @param key - Error message key
+ * @param locale - Current locale
+ * @param params - Optional parameters for dynamic messages
+ */
+declare function getErrorMessage(key: keyof typeof formErrorMessages, locale?: Locale, params?: any): string;
+
+interface MetadataOptions {
+    /** Page title */
+    title: string;
+    /** Page description */
+    description: string;
+    /** Canonical URL */
+    url?: string;
+    /** Open Graph image */
+    image?: string;
+    /** Image alt text */
+    imageAlt?: string;
+    /** Page type @default 'website' */
+    type?: 'website' | 'article';
+    /** Article specific metadata */
+    article?: {
+        publishedTime?: string;
+        modifiedTime?: string;
+        author?: string;
+        tags?: string[];
+    };
+    /** Twitter card type @default 'summary_large_image' */
+    twitterCard?: 'summary' | 'summary_large_image' | 'app' | 'player';
+    /** Twitter handle (without @) */
+    twitterSite?: string;
+    /** Twitter creator handle (without @) */
+    twitterCreator?: string;
+    /** Locale @default 'en' */
+    locale?: string;
+    /** Alternate locales */
+    alternateLocales?: string[];
+    /** Site name */
+    siteName?: string;
+    /** Robots directives */
+    robots?: {
+        index?: boolean;
+        follow?: boolean;
+        googleBot?: {
+            index?: boolean;
+            follow?: boolean;
+        };
+    };
+    /** Keywords */
+    keywords?: string[];
+    /** Author */
+    author?: string;
+    /** Additional metadata */
+    other?: Record<string, string>;
+}
+/**
+ * Generate Next.js metadata object for SEO
+ *
+ * Creates a complete Metadata object with Open Graph, Twitter Card,
+ * and other SEO metadata. Compatible with Next.js 13+ App Router.
+ *
+ * @example
+ * // In app/page.tsx
+ * export const metadata = generateMetadata({
+ *   title: 'Home - My Company',
+ *   description: 'Leading provider of professional services',
+ *   url: 'https://example.com',
+ *   image: 'https://example.com/og-image.jpg',
+ *   siteName: 'My Company',
+ *   twitterSite: 'mycompany'
+ * })
+ *
+ * @example
+ * // Article page
+ * export const metadata = generateMetadata({
+ *   title: 'Blog Post Title',
+ *   description: 'Article description...',
+ *   type: 'article',
+ *   article: {
+ *     publishedTime: '2024-01-15T00:00:00Z',
+ *     author: 'Jane Doe',
+ *     tags: ['JavaScript', 'React']
+ *   },
+ *   image: '/blog/post-image.jpg'
+ * })
+ *
+ * @example
+ * // With alternates for i18n
+ * export const metadata = generateMetadata({
+ *   title: 'Welcome',
+ *   description: 'Description',
+ *   locale: 'en',
+ *   alternateLocales: ['fr', 'es'],
+ *   url: 'https://example.com'
+ * })
+ */
+declare function generateMetadata({ title, description, url, image, imageAlt, type, article, twitterCard, twitterSite, twitterCreator, locale, alternateLocales, siteName, robots, keywords, author, other }: MetadataOptions): Metadata;
+/**
+ * Generate metadata for a blog post or article
+ *
+ * Specialized helper for article pages with publication metadata.
+ *
+ * @example
+ * export const metadata = generateArticleMetadata({
+ *   title: 'My Blog Post',
+ *   description: 'Post description',
+ *   image: '/blog/post.jpg',
+ *   publishedTime: '2024-01-15T00:00:00Z',
+ *   author: 'Jane Doe',
+ *   tags: ['JavaScript', 'Web Development']
+ * })
+ */
+declare function generateArticleMetadata({ title, description, image, publishedTime, modifiedTime, author, tags, url, siteName, twitterSite }: {
+    title: string;
+    description: string;
+    image?: string;
+    publishedTime?: string;
+    modifiedTime?: string;
+    author?: string;
+    tags?: string[];
+    url?: string;
+    siteName?: string;
+    twitterSite?: string;
+}): Metadata;
+
+/**
+ * Base schema.org Thing type
+ * @see https://schema.org/Thing
+ */
+interface Thing {
+    '@type': string;
+    '@id'?: string;
+    name?: string;
+    description?: string;
+    image?: string | string[];
+    url?: string;
+    [key: string]: unknown;
+}
+/**
+ * Organization schema
+ * @see https://schema.org/Organization
+ */
+interface Organization extends Thing {
+    '@type': 'Organization';
+    name: string;
+    url?: string;
+    logo?: string;
+    description?: string;
+    email?: string;
+    telephone?: string;
+    address?: PostalAddress;
+    sameAs?: string[];
+    contactPoint?: ContactPoint[];
+    foundingDate?: string;
+    founders?: Person[];
+}
+/**
+ * Postal address schema
+ * @see https://schema.org/PostalAddress
+ */
+interface PostalAddress extends Thing {
+    '@type': 'PostalAddress';
+    streetAddress?: string;
+    addressLocality?: string;
+    addressRegion?: string;
+    postalCode?: string;
+    addressCountry?: string;
+}
+/**
+ * Contact point schema
+ * @see https://schema.org/ContactPoint
+ */
+interface ContactPoint extends Thing {
+    '@type': 'ContactPoint';
+    telephone?: string;
+    email?: string;
+    contactType?: string;
+    availableLanguage?: string[];
+    areaServed?: string[];
+}
+/**
+ * Person schema
+ * @see https://schema.org/Person
+ */
+interface Person extends Thing {
+    '@type': 'Person';
+    name: string;
+    email?: string;
+    jobTitle?: string;
+    image?: string;
+    sameAs?: string[];
+    url?: string;
+}
+/**
+ * WebSite schema with search action
+ * @see https://schema.org/WebSite
+ */
+interface WebSite extends Thing {
+    '@type': 'WebSite';
+    name: string;
+    url: string;
+    description?: string;
+    publisher?: Organization;
+    potentialAction?: SearchAction;
+}
+/**
+ * Search action for site search
+ * @see https://schema.org/SearchAction
+ */
+interface SearchAction {
+    '@type': 'SearchAction';
+    target: {
+        '@type': 'EntryPoint';
+        urlTemplate: string;
+    };
+    'query-input': string;
+}
+/**
+ * Product schema
+ * @see https://schema.org/Product
+ */
+interface Product extends Thing {
+    '@type': 'Product' | 'SoftwareApplication';
+    name: string;
+    description?: string;
+    image?: string | string[];
+    brand?: Organization | string;
+    offers?: Offer | Offer[];
+    aggregateRating?: AggregateRating;
+    review?: Review[];
+}
+/**
+ * Offer schema for products/services
+ * @see https://schema.org/Offer
+ */
+interface Offer extends Thing {
+    '@type': 'Offer';
+    price: string | number;
+    priceCurrency: string;
+    priceValidUntil?: string;
+    availability?: 'InStock' | 'OutOfStock' | 'PreOrder' | 'Discontinued';
+    url?: string;
+    seller?: Organization;
+}
+/**
+ * Aggregate rating schema
+ * @see https://schema.org/AggregateRating
+ */
+interface AggregateRating extends Thing {
+    '@type': 'AggregateRating';
+    ratingValue: number | string;
+    reviewCount?: number;
+    bestRating?: number | string;
+    worstRating?: number | string;
+}
+/**
+ * Review schema
+ * @see https://schema.org/Review
+ */
+interface Review extends Thing {
+    '@type': 'Review';
+    author: Person | Organization | string;
+    datePublished?: string;
+    reviewBody?: string;
+    reviewRating?: Rating;
+}
+/**
+ * Rating schema
+ * @see https://schema.org/Rating
+ */
+interface Rating extends Thing {
+    '@type': 'Rating';
+    ratingValue: number | string;
+    bestRating?: number | string;
+    worstRating?: number | string;
+}
+/**
+ * FAQ Page schema
+ * @see https://schema.org/FAQPage
+ */
+interface FAQPage extends Thing {
+    '@type': 'FAQPage';
+    mainEntity: Question[];
+}
+/**
+ * Question schema for FAQ
+ * @see https://schema.org/Question
+ */
+interface Question extends Thing {
+    '@type': 'Question';
+    name: string;
+    acceptedAnswer: Answer;
+}
+/**
+ * Answer schema for FAQ
+ * @see https://schema.org/Answer
+ */
+interface Answer extends Thing {
+    '@type': 'Answer';
+    text: string;
+}
+/**
+ * Article schema
+ * @see https://schema.org/Article
+ */
+interface Article extends Thing {
+    '@type': 'Article' | 'BlogPosting' | 'NewsArticle';
+    headline: string;
+    description?: string;
+    image?: string | string[];
+    author: Person | Organization | string;
+    publisher: Organization;
+    datePublished: string;
+    dateModified?: string;
+    mainEntityOfPage?: string;
+}
+/**
+ * Breadcrumb list schema
+ * @see https://schema.org/BreadcrumbList
+ */
+interface BreadcrumbList extends Thing {
+    '@type': 'BreadcrumbList';
+    itemListElement: ListItem[];
+}
+/**
+ * List item for breadcrumbs
+ * @see https://schema.org/ListItem
+ */
+interface ListItem extends Thing {
+    '@type': 'ListItem';
+    position: number;
+    name: string;
+    item?: string;
+}
+/**
+ * Create Organization structured data
+ *
+ * @example
+ * ```tsx
+ * const org = createOrganization({
+ *   name: 'Acme Inc',
+ *   url: 'https://acme.com',
+ *   logo: 'https://acme.com/logo.png',
+ *   sameAs: [
+ *     'https://twitter.com/acme',
+ *     'https://linkedin.com/company/acme'
+ *   ]
+ * });
+ * ```
+ */
+declare function createOrganization(data: Omit<Organization, '@type'>): Organization;
+/**
+ * Create WebSite structured data with search action
+ *
+ * @example
+ * ```tsx
+ * const website = createWebSite({
+ *   name: 'Acme',
+ *   url: 'https://acme.com',
+ *   searchUrlTemplate: 'https://acme.com/search?q={search_term_string}'
+ * });
+ * ```
+ */
+declare function createWebSite(data: {
+    name: string;
+    url: string;
+    description?: string;
+    publisher?: Organization;
+    searchUrlTemplate?: string;
+}): WebSite;
+/**
+ * Create Product structured data
+ *
+ * @example
+ * ```tsx
+ * const product = createProduct({
+ *   name: 'Premium Email Plan',
+ *   description: 'Unlimited emails, advanced features',
+ *   image: 'https://acme.com/premium.jpg',
+ *   offers: {
+ *     price: '99.00',
+ *     priceCurrency: 'USD',
+ *     availability: 'InStock'
+ *   }
+ * });
+ * ```
+ */
+declare function createProduct(data: Omit<Product, '@type'>): Product;
+/**
+ * Create FAQ Page structured data
+ *
+ * @example
+ * ```tsx
+ * const faq = createFAQPage([
+ *   {
+ *     question: 'What is your refund policy?',
+ *     answer: 'We offer a 30-day money-back guarantee.'
+ *   },
+ *   {
+ *     question: 'Do you offer support?',
+ *     answer: 'Yes, 24/7 email and chat support is included.'
+ *   }
+ * ]);
+ * ```
+ */
+declare function createFAQPage(faqs: Array<{
+    question: string;
+    answer: string;
+}>): FAQPage;
+/**
+ * Create Article structured data
+ *
+ * @example
+ * ```tsx
+ * const article = createArticle({
+ *   headline: '10 Email Marketing Tips',
+ *   description: 'Learn how to improve your email campaigns',
+ *   author: { name: 'Jane Doe' },
+ *   publisher: {
+ *     name: 'Acme',
+ *     logo: 'https://acme.com/logo.png'
+ *   },
+ *   datePublished: '2024-01-15T10:00:00Z',
+ *   image: 'https://acme.com/blog/tips.jpg'
+ * });
+ * ```
+ */
+declare function createArticle(data: {
+    headline: string;
+    description?: string;
+    image?: string | string[];
+    author: Person | string;
+    publisher: Organization;
+    datePublished: string;
+    dateModified?: string;
+    mainEntityOfPage?: string;
+    type?: 'Article' | 'BlogPosting' | 'NewsArticle';
+}): Article;
+/**
+ * Create Breadcrumb List structured data
+ *
+ * @example
+ * ```tsx
+ * const breadcrumbs = createBreadcrumbList([
+ *   { name: 'Home', url: 'https://acme.com' },
+ *   { name: 'Blog', url: 'https://acme.com/blog' },
+ *   { name: 'Email Tips', url: 'https://acme.com/blog/email-tips' }
+ * ]);
+ * ```
+ */
+declare function createBreadcrumbList(items: Array<{
+    name: string;
+    url?: string;
+}>): BreadcrumbList;
+/**
+ * Serialize structured data to JSON-LD string
+ * Safe for use in script tags
+ */
+declare function serializeStructuredData(data: Thing | Thing[]): string;
+
+/**
+ * Change frequency for sitemap entries
+ * @see https://www.sitemaps.org/protocol.html
+ */
+type ChangeFrequency = 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
+/**
+ * A single URL entry in the sitemap
+ */
+interface SitemapEntry {
+    /** Absolute URL of the page */
+    url: string;
+    /** Last modification date (ISO 8601 format) */
+    lastModified?: string | Date;
+    /** How frequently the page is likely to change */
+    changeFrequency?: ChangeFrequency;
+    /** Priority of this URL relative to other URLs (0.0 to 1.0) */
+    priority?: number;
+    /** Alternate language versions of this URL */
+    alternates?: Array<{
+        /** Language/locale code (e.g., 'en', 'fr', 'en-US') */
+        hreflang: string;
+        /** Absolute URL for this language version */
+        href: string;
+    }>;
+}
+/**
+ * Configuration for sitemap generation
+ */
+interface SitemapConfig {
+    /** Base URL of the website (e.g., 'https://example.com') */
+    baseUrl: string;
+    /** Array of sitemap entries */
+    entries: SitemapEntry[];
+    /** Pretty print the XML output (default: false) */
+    prettyPrint?: boolean;
+}
+/**
+ * Generate XML sitemap from entries
+ *
+ * Creates a valid sitemap.xml following the sitemaps.org protocol with
+ * support for multi-language pages using hreflang annotations.
+ *
+ * @param config - Sitemap configuration
+ * @returns XML string for sitemap.xml
+ *
+ * @example Basic sitemap
+ * ```tsx
+ * const sitemap = generateSitemap({
+ *   baseUrl: 'https://example.com',
+ *   entries: [
+ *     { url: 'https://example.com', priority: 1.0, changeFrequency: 'weekly' },
+ *     { url: 'https://example.com/about', priority: 0.8 },
+ *     { url: 'https://example.com/products', priority: 0.9, changeFrequency: 'daily' }
+ *   ]
+ * });
+ * ```
+ *
+ * @example Multi-language sitemap
+ * ```tsx
+ * const sitemap = generateSitemap({
+ *   baseUrl: 'https://example.com',
+ *   entries: [
+ *     {
+ *       url: 'https://example.com/en/about',
+ *       alternates: [
+ *         { hreflang: 'en', href: 'https://example.com/en/about' },
+ *         { hreflang: 'fr', href: 'https://example.com/fr/about' },
+ *         { hreflang: 'x-default', href: 'https://example.com/en/about' }
+ *       ]
+ *     }
+ *   ]
+ * });
+ * ```
+ */
+declare function generateSitemap(config: SitemapConfig): string;
+/**
+ * Create sitemap entries for multi-language pages
+ *
+ * Helper to generate sitemap entries with proper hreflang annotations
+ * for pages that exist in multiple languages.
+ *
+ * @param baseUrl - Base URL of the website
+ * @param path - Page path without locale prefix (e.g., '/about')
+ * @param locales - Array of locale codes (e.g., ['en', 'fr', 'es'])
+ * @param defaultLocale - Default locale for x-default (optional)
+ * @param options - Additional sitemap entry options
+ * @returns Array of sitemap entries, one per locale
+ *
+ * @example
+ * ```tsx
+ * const entries = createMultiLanguageEntries(
+ *   'https://example.com',
+ *   '/about',
+ *   ['en', 'fr', 'es'],
+ *   'en',
+ *   { priority: 0.8, changeFrequency: 'monthly' }
+ * );
+ * // Creates entries for:
+ * // - /en/about (with alternates to fr, es, x-default)
+ * // - /fr/about (with alternates to en, es, x-default)
+ * // - /es/about (with alternates to en, fr, x-default)
+ * ```
+ */
+declare function createMultiLanguageEntries(baseUrl: string, path: string, locales: string[], defaultLocale?: string, options?: Partial<Omit<SitemapEntry, 'url' | 'alternates'>>): SitemapEntry[];
+/**
+ * Create a single-language sitemap entry
+ *
+ * @param baseUrl - Base URL of the website
+ * @param path - Page path (e.g., '/about')
+ * @param options - Sitemap entry options
+ * @returns Sitemap entry
+ *
+ * @example
+ * ```tsx
+ * const entry = createSitemapEntry(
+ *   'https://example.com',
+ *   '/about',
+ *   { priority: 0.8, changeFrequency: 'monthly' }
+ * );
+ * ```
+ */
+declare function createSitemapEntry(baseUrl: string, path: string, options?: Partial<Omit<SitemapEntry, 'url'>>): SitemapEntry;
+/**
+ * Validate sitemap entry
+ *
+ * Checks for common issues in sitemap entries.
+ *
+ * @param entry - Sitemap entry to validate
+ * @returns Array of error messages (empty if valid)
+ */
+declare function validateSitemapEntry(entry: SitemapEntry): string[];
+/**
+ * Validate entire sitemap configuration
+ *
+ * @param config - Sitemap configuration to validate
+ * @returns Object with isValid flag and array of errors
+ */
+declare function validateSitemap(config: SitemapConfig): {
+    isValid: boolean;
+    errors: Array<{
+        entry?: SitemapEntry;
+        messages: string[];
+    }>;
+};
+
+interface TrackedLinkProps {
+    href: string;
+    children: React.ReactNode;
+    className?: string;
+    trackingType?: 'cta' | 'navigation' | 'outbound' | 'auto';
+    ctaLocation?: string;
+    ctaType?: 'signup' | 'trial' | 'contact' | 'download' | 'other';
+    navLocation?: 'header' | 'footer' | 'content' | 'mobile';
+    onClick?: () => void;
+    [key: string]: unknown;
+}
+/**
+ * Link component with built-in analytics tracking
+ * Automatically determines tracking type if set to 'auto'
+ */
+declare function TrackedLink({ href, children, className, trackingType, ctaLocation, ctaType, navLocation, onClick, ...props }: TrackedLinkProps): react_jsx_runtime.JSX.Element;
+
+interface Feature {
+    id: string;
+    icon?: ReactNode;
+    name: string;
+    description: string;
+    benefits?: string[];
+    useCases?: string[];
+    learnMoreHref?: string;
+}
+interface FeatureCategory {
+    id: string;
+    name: string;
+    description: string;
+    features: Feature[];
+}
+interface FeaturesGridProps {
+    categories: FeatureCategory[];
+    className?: string;
+    locale?: 'fr' | 'en';
+}
+declare function FeaturesGrid({ categories, className, locale }: FeaturesGridProps): react_jsx_runtime.JSX.Element;
+
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * Visual variant of the button
+     * - outlined: Rounded with border (primary brand style)
+     * - filled: Solid background with shadow
+     * - text: Text-only button without border
+     * - ghost: Transparent background, visible on hover
+     * - link: Styled like a link, but button semantics
+     * - destructive: Red variant for delete/remove actions
+     */
+    variant?: 'outlined' | 'filled' | 'text' | 'ghost' | 'link' | 'destructive';
+    /**
+     * Size of the button
+     */
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /**
+     * Full width button
+     */
+    fullWidth?: boolean;
+    /**
+     * Loading state - shows spinner and disables button
+     */
+    loading?: boolean;
+    /**
+     * Custom text to show during loading
+     */
+    loadingText?: string;
+    /**
+     * Success state - shows checkmark animation
+     */
+    success?: boolean;
+    /**
+     * Custom text to show during success
+     */
+    successText?: string;
+    /**
+     * Duration to show success state before reverting (ms)
+     */
+    successDuration?: number;
+    /**
+     * Icon element to display
+     */
+    icon?: ReactNode;
+    /**
+     * Position of the icon
+     */
+    iconPosition?: 'left' | 'right';
+    /**
+     * Icon-only button (no text)
+     */
+    iconOnly?: boolean;
+    /**
+     * Tooltip text to show when button is disabled
+     */
+    disabledTooltip?: string;
+    /**
+     * Enable ripple effect on click
+     */
+    ripple?: boolean;
+    /**
+     * Analytics event name to track on click
+     * Automatically tracks button clicks with this event name
+     */
+    trackingEvent?: string;
+    /**
+     * Additional properties to send with tracking event
+     * Merged with automatic button properties (variant, text, href)
+     */
+    trackingProps?: Record<string, unknown>;
+    /**
+     * Link href (for navigation buttons)
+     */
+    href?: string;
+}
+
+interface CardProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * Padding variant
+     */
+    padding?: 'none' | 'sm' | 'md' | 'lg';
+    /**
+     * Whether to show a border
+     */
+    bordered?: boolean;
+    /**
+     * Whether to show a shadow
+     */
+    shadow?: boolean;
+}
+
+interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
+    /**
+     * Label text for the input
+     */
+    label?: string;
+    /**
+     * Error message to display
+     */
+    error?: string;
+    /**
+     * Helper text to display below input
+     */
+    helperText?: string;
+    /**
+     * Full width input
+     */
+    fullWidth?: boolean;
+}
+
+interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    /**
+     * Label text for the textarea
+     */
+    label?: string;
+    /**
+     * Error message to display
+     */
+    error?: string;
+    /**
+     * Helper text to display below textarea
+     */
+    helperText?: string;
+    /**
+     * Full width textarea
+     */
+    fullWidth?: boolean;
+}
+
+interface BreadcrumbItem {
+    label: string;
+    href?: string;
+}
+interface BreadcrumbProps {
+    items: BreadcrumbItem[];
+    className?: string;
+}
+
+type BadgeType = 'ssl-secure' | 'money-back-30' | 'money-back-60' | 'money-back-90' | 'bbb-accredited' | 'satisfaction-guaranteed' | 'free-shipping' | 'privacy-protected' | '24-7-support' | 'secure-payment';
+interface CustomBadge {
+    type: 'custom';
+    image: string;
+    alt: string;
+    tooltip?: string;
+}
+type Badge = BadgeType | CustomBadge;
+
+interface HeroAnimations {
+    /** Animation type for headline */
+    headline?: 'fadeInUp' | 'fadeIn' | 'slideInLeft' | 'none';
+    /** Animation type for CTA buttons */
+    cta?: 'fadeInUp' | 'fadeIn' | 'none';
+    /** Stagger delay between elements (seconds) */
+    stagger?: number;
+    /** Show scroll indicator */
+    scrollIndicator?: boolean;
+}
+interface HeroSectionProps {
+    locale: Locale;
+    content: HeroContent;
+    /** Animation configuration */
+    animations?: HeroAnimations;
+    /** Show sticky CTA after scrolling past hero */
+    stickyCtaAfterScroll?: boolean;
+    /** Trust badges to display */
+    trustBadges?: Badge[];
+    /** Background effect variant */
+    backgroundEffect?: 'none' | 'particles' | 'gradient-shift' | 'mesh';
+}
+
+interface OfficeHours {
+    monday?: {
+        open: string;
+        close: string;
+    };
+    tuesday?: {
+        open: string;
+        close: string;
+    };
+    wednesday?: {
+        open: string;
+        close: string;
+    };
+    thursday?: {
+        open: string;
+        close: string;
+    };
+    friday?: {
+        open: string;
+        close: string;
+    };
+    saturday?: {
+        open: string;
+        close: string;
+    };
+    sunday?: {
+        open: string;
+        close: string;
+    };
+}
+interface Location {
+    name: LocalizedString | string;
+    address: string;
+    phone?: string;
+    email?: string;
+    hours?: OfficeHours;
+    coordinates?: {
+        lat: number;
+        lng: number;
+    };
+}
+interface MapConfig {
+    provider?: 'google' | 'static' | 'link';
+    apiKey?: string;
+    zoom?: number;
+}
+interface SpamProtection {
+    honeypot?: boolean;
+    recaptcha?: string;
+}
+interface FormIntegration {
+    type: 'sendgrid' | 'mailgun' | 'webhook' | 'custom';
+    config: Record<string, any>;
+}
+interface ContactFormConfig {
+    enabled?: boolean;
+    fields?: Array<'name' | 'email' | 'phone' | 'subject' | 'message' | 'attachment'>;
+    requiredFields?: Array<'name' | 'email' | 'phone' | 'subject' | 'message'>;
+    onSubmit?: (data: ContactFormData) => Promise<void>;
+    spamProtection?: SpamProtection;
+    integration?: FormIntegration;
+}
+interface ContactSectionProps {
+    locale: Locale;
+    title?: LocalizedString | string;
+    description?: LocalizedString | string;
+    form?: ContactFormConfig;
+    locations?: Location[];
+    defaultLocation?: number;
+    map?: MapConfig;
+    showMap?: boolean;
+    showInfo?: boolean;
+    timezone?: string;
+    showStatus?: boolean;
+    className?: string;
+}
+interface ContactFormData {
+    name: string;
+    email: string;
+    phone?: string;
+    subject?: string;
+    message: string;
+    attachment?: File;
+    _honeypot?: string;
+}
+
+interface AboutSectionProps {
+    locale: Locale;
+    content: AboutContent;
+}
+
+interface ServicesSectionProps {
+    locale: Locale;
+    content: ServicesContent;
+}
+
+interface TestimonialContent {
+    quote: {
+        [locale: string]: string;
+    };
+    author?: {
+        [locale: string]: string;
+    };
+    role?: {
+        [locale: string]: string;
+    };
+    company?: {
+        [locale: string]: string;
+    };
+}
+interface TestimonialSectionProps {
+    locale: Locale;
+    content: TestimonialContent;
+}
+
+interface ServicePageLayoutProps {
+    locale: Locale;
+    title: string;
+    description: string;
+    children?: ReactNode;
+    breadcrumbItems: BreadcrumbItem[];
+    showCTA?: boolean;
+}
+
+interface HeaderProps {
+    locale: Locale;
+    config: HeaderConfig;
+}
+
+interface FooterProps {
+    locale: Locale;
+    config: FooterConfig;
+}
+
+interface LanguageSwitcherProps {
+    currentLocale: string;
+    className?: string;
+    customSlugTranslations?: SlugTranslations;
+}
+
+interface SkipLinkProps {
+    /** Target element ID to skip to (e.g., "main-content") */
+    href: string;
+    /** Link text */
+    children: ReactNode;
+    /** Additional CSS classes */
+    className?: string;
+}
+
+type AnnouncementPriority = 'polite' | 'assertive';
+interface A11yAnnouncerProps {
+    /** Announcement message */
+    message?: string;
+    /** Priority level - 'polite' waits for pause, 'assertive' interrupts */
+    priority?: AnnouncementPriority;
+    /** Clear message after this many milliseconds */
+    clearAfter?: number;
+}
+
+type IconName = string;
+interface IconProps extends Omit<LucideProps, 'ref'> {
+    /** Icon name from Lucide React */
+    name: IconName;
+    /** Icon size in pixels @default 24 */
+    size?: number;
+    /** Additional CSS classes */
+    className?: string;
+}
+
+interface CodeBlockProps {
+    /** Code to display */
+    code: string;
+    /** Language for syntax highlighting @default 'tsx' */
+    language?: string;
+    /** Show line numbers @default false */
+    showLineNumbers?: boolean;
+    /** Show copy button @default true */
+    showCopy?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+
+interface LazySectionProps {
+    /** Component to lazy load */
+    component: () => Promise<{
+        default: ComponentType<any>;
+    }>;
+    /** Props to pass to the lazy component */
+    componentProps?: Record<string, any>;
+    /** Custom loading component */
+    fallback?: ReactNode;
+    /** Load when in viewport @default true */
+    loadOnView?: boolean;
+    /** Viewport intersection threshold @default 0.1 */
+    threshold?: number;
+    /** Additional CSS classes */
+    className?: string;
+}
+
+interface FormFieldProps {
+    /** Field label text */
+    label?: string;
+    /** Field name (matches form schema) */
+    name: string;
+    /** Error object from React Hook Form */
+    error?: FieldError;
+    /** Optional hint text shown below input */
+    hint?: string;
+    /** Whether field is required */
+    required?: boolean;
+    /** Input element to render */
+    children: ReactNode;
+    /** Additional CSS classes */
+    className?: string;
+}
+
+type ModalSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+interface ModalProps {
+    /** Whether modal is open */
+    open: boolean;
+    /** Callback when open state changes */
+    onOpenChange: (open: boolean) => void;
+    /** Modal title */
+    title?: string;
+    /** Modal description */
+    description?: string;
+    /** Modal size @default 'md' */
+    size?: ModalSize;
+    /** Modal content */
+    children: ReactNode;
+    /** Whether clicking backdrop closes modal @default true */
+    closeOnBackdrop?: boolean;
+    /** Whether ESC key closes modal @default true */
+    closeOnEscape?: boolean;
+}
+
+interface Tab {
+    /** Unique tab identifier */
+    value: string;
+    /** Tab label (bilingual) */
+    label: LocalizedString | string;
+    /** Tab content */
+    content: ReactNode;
+    /** Disabled state */
+    disabled?: boolean;
+}
+interface TabsProps {
+    /** Current locale */
+    locale?: 'en' | 'fr';
+    /** Array of tabs */
+    tabs: Tab[];
+    /** Default active tab value */
+    defaultValue?: string;
+    /** Controlled active tab value */
+    value?: string;
+    /** Callback when tab changes */
+    onValueChange?: (value: string) => void;
+    /** Sync active tab with URL query param @default false */
+    syncWithUrl?: boolean;
+    /** URL query param name @default 'tab' */
+    urlParam?: string;
+    /** Tab variant @default 'underline' */
+    variant?: 'underline' | 'pills' | 'bordered';
+    /** Tab orientation @default 'horizontal' */
+    orientation?: 'horizontal' | 'vertical';
+    /** Additional CSS classes */
+    className?: string;
+}
+
+interface SelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+interface SelectOptionGroup {
+    label: string;
+    options: SelectOption[];
+}
+interface SelectProps {
+    /** Options to display */
+    options: SelectOption[] | SelectOptionGroup[];
+    /** Selected value */
+    value?: string;
+    /** Callback when value changes */
+    onValueChange?: (value: string) => void;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Whether select is disabled */
+    disabled?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+
+interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
+    /** Checkbox label */
+    label?: string;
+    /** Description text below label */
+    description?: string;
+    /** Error message */
+    error?: string;
+    /** Size variant @default 'md' */
+    size?: 'sm' | 'md' | 'lg';
+}
+
+interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
+    /** Radio label */
+    label?: string;
+    /** Description text below label */
+    description?: string;
+    /** Error message */
+    error?: string;
+    /** Size variant @default 'md' */
+    size?: 'sm' | 'md' | 'lg';
+}
+
+export { type A11yAnnouncerProps, type ABTestEvent, AboutContent, type AboutSectionProps, type AggregateRating, type AnalyticsEvent, type AnnouncementPriority, type Answer, type Article, type BreadcrumbItem, type BreadcrumbList, type BreadcrumbProps, type ButtonProps, type CTAClickEvent, type CTAType, type CardProps, type ChangeFrequency, type CheckboxProps, type CodeBlockProps, type ContactFormConfig, type ContactFormData, type ContactPoint, type ContactSectionProps, type ConversionEvent, type ConversionType, type EventCategory, type FAQPage, type Feature, type FeatureAction, type FeatureCategory, type FeatureEvent, FeaturesGrid, FooterConfig, type FooterProps, type FormAction, type FormEvent, type FormFieldProps, HeaderConfig, type HeaderProps, type HeroAnimations, HeroContent, type HeroSectionProps, type I18nConfig, type IconName, type IconProps, type InputProps, LOCALE_COOKIE_NAME, type LanguagePreference, type LanguageSwitcherProps, type LazySectionProps, type ListItem, type Locale, type LocaleCookieConfig, type LocalePrefix, LocalizedString, type Location, type MetadataOptions, type ModalProps, type NavigationEvent, type NavigationLocation, type Offer, type Organization, type PageViewEvent, type Person, type Policy, type PolicyMetadata, type PostalAddress, type PricingAction, type PricingEvent, type Product, type Question, type RadioProps, type Rating, type Review, type ScrollDepth, type ScrollDepthEvent, type SearchAction, type SelectProps, type ServicePageLayoutProps, ServicesContent, type ServicesSectionProps, type SitemapConfig, type SitemapEntry, type SkipLinkProps, type SlugTranslations, type TabsProps, type TestimonialSectionProps, type TextareaProps, ThemeConfig, type Thing, TrackedLink, type ValidLocale, type VideoAction, type VideoEvent, type WebSite, cn, createArticle, createBreadcrumbList, createFAQPage, createI18nMiddleware, createMultiLanguageEntries, createOrganization, createProduct, createSitemapEntry, createWebSite, creditCardSchema, dateString, defaultLocale, defaultSlugTranslations, emailSchema, fileSchema, formErrorMessages, formatCurrency, formatDate, formatDateRange, formatFileSize, formatList, formatLocaleDisplay, formatNumber, formatRelativeTime, generateArticleMetadata, generateDesignTokens, generateMetadata, generateSitemap, generateThemeCSS, getAllPolicies, getAlternateLocales, getDefaultLocale, getErrorMessage, getFontConfig, getFontVariables, getI18nConfig, getLocaleAutonym, getLocaleCookieConfig, getLocaleFromCookie, getLocaleLabel, getLocaleLabels, getLocaleName, getLocaleNames, getLocalePrefix, getLocales, getLocalizedString, getNavigationString, getPolicyLocales, getPolicySlugs, getRelativeTime, getRtlLocales, getTextDirection, imageSchema, isI18nConfigInitialized, isLocaleDetectionEnabled, isRtlLocale, isSupportedLocale, loadPolicy, locales, matchLocale, mustBeTrue, normalizeLocale, numericString, optionalString, passwordSchema, phoneSchema, postalCodeSchema, replaceVariables, requiredString, serializeStructuredData, setI18nConfig, setLocaleCookie, trackABTestEvent, trackCTAClick, trackConversion, trackError, trackEvent, trackFeatureEngagement, trackFormEvent, trackNavigation, trackOutboundLink, trackPageView, trackPricingEvent, trackResourceDownload, trackScrollDepth, trackSearch, trackVideoEvent, translateSlug, urlSchema, validateLocale, validateSitemap, validateSitemapEntry };