@nice2dev/icons 1.0.4 → 1.0.6

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/node_modules/react-dom/client.js

@@ -0,0 +1,37 @@
+import { __exports as client } from '../../_virtual/client2.js';
+import require$$0 from 'react-dom';
+
+var hasRequiredClient;
+
+function requireClient () {
+	if (hasRequiredClient) return client;
+	hasRequiredClient = 1;
+
+	var m = require$$0;
+	if (process.env.NODE_ENV === 'production') {
+	  client.createRoot = m.createRoot;
+	  client.hydrateRoot = m.hydrateRoot;
+	} else {
+	  var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+	  client.createRoot = function(c, o) {
+	    i.usingClientEntryPoint = true;
+	    try {
+	      return m.createRoot(c, o);
+	    } finally {
+	      i.usingClientEntryPoint = false;
+	    }
+	  };
+	  client.hydrateRoot = function(c, h, o) {
+	    i.usingClientEntryPoint = true;
+	    try {
+	      return m.hydrateRoot(c, h, o);
+	    } finally {
+	      i.usingClientEntryPoint = false;
+	    }
+	  };
+	}
+	return client;
+}
+
+export { requireClient as __require };
+//# sourceMappingURL=client.js.map

package/dist/esm/node_modules/react-dom/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sources":["../../../../../../node_modules/react-dom/client.js"],"sourcesContent":["'use strict';\n\nvar m = require('react-dom');\nif (process.env.NODE_ENV === 'production') {\n  exports.createRoot = m.createRoot;\n  exports.hydrateRoot = m.hydrateRoot;\n} else {\n  var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n  exports.createRoot = function(c, o) {\n    i.usingClientEntryPoint = true;\n    try {\n      return m.createRoot(c, o);\n    } finally {\n      i.usingClientEntryPoint = false;\n    }\n  };\n  exports.hydrateRoot = function(c, h, o) {\n    i.usingClientEntryPoint = true;\n    try {\n      return m.hydrateRoot(c, h, o);\n    } finally {\n      i.usingClientEntryPoint = false;\n    }\n  };\n}\n"],"names":[],"mappings":";;;;;;;;;CAEA,IAAI,CAAC,GAAG,UAAoB;AAC5B,CAAA,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY,EAAE;AAC3C,GAAE,MAAA,CAAA,UAAkB,GAAG,CAAC,CAAC,UAAU;AACnC,GAAE,MAAA,CAAA,WAAmB,GAAG,CAAC,CAAC,WAAW;AACrC,CAAA,CAAC,MAAM;AACP,GAAE,IAAI,CAAC,GAAG,CAAC,CAAC,kDAAkD;AAC9D,GAAE,iBAAkB,GAAG,SAAS,CAAC,EAAE,CAAC,EAAE;AACtC,KAAI,CAAC,CAAC,qBAAqB,GAAG,IAAI;AAClC,KAAI,IAAI;OACF,OAAO,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC;AAC/B,KAAA,CAAK,SAAS;AACd,OAAM,CAAC,CAAC,qBAAqB,GAAG,KAAK;AACrC,KAAA;GACA,CAAG;GACD,MAAA,CAAA,WAAmB,GAAG,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;AAC1C,KAAI,CAAC,CAAC,qBAAqB,GAAG,IAAI;AAClC,KAAI,IAAI;OACF,OAAO,CAAC,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;AACnC,KAAA,CAAK,SAAS;AACd,OAAM,CAAC,CAAC,qBAAqB,GAAG,KAAK;AACrC,KAAA;GACA,CAAG;AACH,CAAA;;;;;;","x_google_ignoreList":[0]}

package/dist/types/NiceDesktopIconExporter.d.ts

@@ -0,0 +1,119 @@
+/**
+ * @file NiceDesktopIconExporter.tsx
+ * @module @nice2dev/icons
+ * @description PRO-28.1 — Desktop Icon Exporter
+ *
+ * Comprehensive desktop icon export utility with:
+ * - Multiple sizes (16, 24, 32, 48, 64, 128, 256, 512)
+ * - High-DPI / Retina variants (@2x, @3x)
+ * - Windows .ico export (multi-resolution ICO)
+ * - macOS .icns export
+ * - Linux PNG set export (hicolor theme)
+ * - ZIP package download
+ */
+import React, { type ComponentType } from 'react';
+import type { NtdIconProps } from './types';
+export interface DesktopIconSize {
+    size: number;
+    label: string;
+    platforms: ('windows' | 'macos' | 'linux')[];
+}
+export interface RetinaVariant {
+    scale: number;
+    suffix: string;
+}
+export interface ExportedIcon {
+    filename: string;
+    size: number;
+    scale: number;
+    platform: string;
+    dataUrl: string;
+    blob?: Blob;
+}
+export interface IconExportConfig {
+    /** App/icon name for filenames */
+    name: string;
+    /** Include Windows ICO format */
+    includeWindows: boolean;
+    /** Include macOS ICNS format */
+    includeMacOS: boolean;
+    /** Include Linux PNG sets */
+    includeLinux: boolean;
+    /** Include Retina/HiDPI variants */
+    includeRetina: boolean;
+    /** Background color (transparent if not set) */
+    backgroundColor?: string;
+    /** Padding around icon (0-0.5, percentage of size) */
+    padding: number;
+    /** Icon fill color */
+    fillColor: string;
+    /** Export sizes to include */
+    sizes: number[];
+}
+export interface UseDesktopIconExporterReturn {
+    config: IconExportConfig;
+    setConfig: React.Dispatch<React.SetStateAction<IconExportConfig>>;
+    icons: ExportedIcon[];
+    isExporting: boolean;
+    progress: number;
+    exportAll: () => Promise<void>;
+    exportWindows: () => Promise<string>;
+    exportMacOS: () => Promise<string>;
+    exportLinux: () => Promise<ExportedIcon[]>;
+    downloadAll: () => Promise<void>;
+    downloadSingle: (icon: ExportedIcon) => void;
+}
+/** Standard desktop icon sizes used across platforms */
+export declare const DESKTOP_ICON_SIZES: DesktopIconSize[];
+/** Retina/HiDPI scale factors */
+export declare const RETINA_VARIANTS: RetinaVariant[];
+/** Linux hicolor theme icon directories */
+export declare const LINUX_HICOLOR_DIRS: {
+    size: number;
+    dir: string;
+}[];
+/**
+ * Hook for exporting desktop icons in multiple formats and sizes.
+ *
+ * @example
+ * ```tsx
+ * const { exportAll, downloadAll, icons, isExporting } = useDesktopIconExporter(MyIcon);
+ *
+ * // Export all icons
+ * await exportAll();
+ *
+ * // Download as ZIP
+ * await downloadAll();
+ * ```
+ */
+export declare function useDesktopIconExporter(icon: ComponentType<NtdIconProps>, initialConfig?: Partial<IconExportConfig>): UseDesktopIconExporterReturn;
+export interface NiceDesktopIconExporterProps {
+    /** Icon component to export */
+    icon: ComponentType<NtdIconProps>;
+    /** Initial configuration */
+    initialConfig?: Partial<IconExportConfig>;
+    /** Callback when icons are exported */
+    onExport?: (icons: ExportedIcon[]) => void;
+    /** Custom class name */
+    className?: string;
+}
+/**
+ * Desktop icon exporter component with UI for configuring and downloading icons.
+ *
+ * @example
+ * ```tsx
+ * import { NiceDesktopIconExporter } from '@nice2dev/icons';
+ * import { NtdRocket } from '@nice2dev/icons/paths';
+ *
+ * function App() {
+ *   return (
+ *     <NiceDesktopIconExporter
+ *       icon={NtdRocket}
+ *       initialConfig={{ name: 'my-app', fillColor: '#ff6b35' }}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export declare const NiceDesktopIconExporter: React.FC<NiceDesktopIconExporterProps>;
+export default NiceDesktopIconExporter;

package/dist/types/NiceFaviconGenerator.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @file NiceFaviconGenerator.tsx
+ * @module @nice2dev/icons
+ * @description PRO-28.4 — Favicon Generator Component
+ *
+ * Advanced favicon generator with:
+ * - All standard sizes (16, 32, 48, 180, 192, 512)
+ * - manifest.json generation
+ * - Apple touch icon support
+ * - Windows tile support
+ */
+import React, { type ComponentType } from 'react';
+import type { NtdIconProps } from './types';
+export interface FaviconSize {
+    name: string;
+    size: number;
+    purpose: string;
+    format: 'png' | 'ico' | 'svg';
+}
+export interface ManifestConfig {
+    name: string;
+    shortName: string;
+    description?: string;
+    themeColor: string;
+    backgroundColor: string;
+    display: 'standalone' | 'fullscreen' | 'minimal-ui' | 'browser';
+    startUrl: string;
+}
+export interface GeneratedAsset {
+    filename: string;
+    size: number;
+    purpose: string;
+    dataUrl: string;
+    blob?: Blob;
+}
+export interface NiceFaviconGeneratorProps {
+    /** Icon component to convert */
+    icon: ComponentType<NtdIconProps>;
+    /** Icon fill color */
+    fill?: string;
+    /** Initial manifest config */
+    manifestConfig?: Partial<ManifestConfig>;
+    /** Callback when assets generated */
+    onGenerate?: (assets: GeneratedAsset[], manifest: string) => void;
+    /** Custom class */
+    className?: string;
+}
+export interface UseFaviconGeneratorReturn {
+    config: ManifestConfig;
+    setConfig: React.Dispatch<React.SetStateAction<ManifestConfig>>;
+    assets: GeneratedAsset[];
+    isGenerating: boolean;
+    generate: () => Promise<void>;
+    downloadAll: () => void;
+    downloadSingle: (asset: GeneratedAsset) => void;
+    getManifestJson: () => string;
+    getHtmlTags: () => string;
+}
+export declare function useFaviconGenerator(icon: ComponentType<NtdIconProps>, fill?: string, initialConfig?: Partial<ManifestConfig>): UseFaviconGeneratorReturn;
+/**
+ * Favicon generator component for creating all favicon variants.
+ */
+export declare function NiceFaviconGenerator({ icon, fill, manifestConfig, onGenerate, className, }: NiceFaviconGeneratorProps): React.ReactElement;
+export default NiceFaviconGenerator;

package/dist/types/NiceIconEditor.d.ts

@@ -0,0 +1,97 @@
+/**
+ * @file NiceIconEditor.tsx
+ * @module @nice2dev/icons
+ * @description PRO-28.4 — Icon Editor Component
+ *
+ * Simple editor for modifying existing icons:
+ * - Change colors (fill, stroke)
+ * - Combine icons (badge/overlay)
+ * - Scale / transform
+ * - Export to multiple formats
+ */
+import React, { type ComponentType } from 'react';
+import type { NtdIconProps } from './types';
+export interface IconEditorState {
+    /** Primary fill color */
+    fill: string;
+    /** Stroke color */
+    stroke: string;
+    /** Stroke width */
+    strokeWidth: number;
+    /** Size in pixels */
+    size: number;
+    /** Rotation in degrees */
+    rotation: number;
+    /** Horizontal flip */
+    flipX: boolean;
+    /** Vertical flip */
+    flipY: boolean;
+    /** Opacity (0-1) */
+    opacity: number;
+    /** Badge/overlay icon */
+    badge?: {
+        icon: ComponentType<NtdIconProps>;
+        position: BadgePosition;
+        size: number;
+        fill: string;
+    };
+}
+export type BadgePosition = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+export type ExportFormat = 'svg' | 'png' | 'ico' | 'base64' | 'react';
+export interface ExportOptions {
+    format: ExportFormat;
+    size?: number;
+    backgroundColor?: string;
+    padding?: number;
+}
+export interface NiceIconEditorProps {
+    /** Icon to edit */
+    icon: ComponentType<NtdIconProps>;
+    /** Icon name */
+    iconName?: string;
+    /** Initial editor state */
+    defaultState?: Partial<IconEditorState>;
+    /** Called when state changes */
+    onChange?: (state: IconEditorState) => void;
+    /** Called on export */
+    onExport?: (data: string, format: ExportFormat) => void;
+    /** Available badges */
+    badges?: {
+        icon: ComponentType<NtdIconProps>;
+        name: string;
+    }[];
+    /** Custom color presets */
+    colorPresets?: string[];
+    /** Custom size presets */
+    sizePresets?: number[];
+    /** Show advanced controls */
+    showAdvanced?: boolean;
+    /** Custom class */
+    className?: string;
+}
+export interface UseIconEditorOptions {
+    defaultState?: Partial<IconEditorState>;
+    onChange?: (state: IconEditorState) => void;
+}
+export interface UseIconEditorReturn {
+    state: IconEditorState;
+    setFill: (color: string) => void;
+    setStroke: (color: string) => void;
+    setStrokeWidth: (width: number) => void;
+    setSize: (size: number) => void;
+    setRotation: (degrees: number) => void;
+    setFlipX: (flip: boolean) => void;
+    setFlipY: (flip: boolean) => void;
+    setOpacity: (opacity: number) => void;
+    setBadge: (badge: IconEditorState['badge']) => void;
+    reset: () => void;
+}
+/**
+ * Hook for managing icon editor state.
+ */
+export declare function useIconEditor(options?: UseIconEditorOptions): UseIconEditorReturn;
+/**
+ * Icon editor component for modifying and exporting icons.
+ */
+export declare function NiceIconEditor({ icon: Icon, iconName, defaultState, onChange, onExport, badges, colorPresets, sizePresets, showAdvanced, className, }: NiceIconEditorProps): React.ReactElement;
+export default NiceIconEditor;

package/dist/types/NiceIconPreview.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @file NiceIconPreview.tsx
+ * @module @nice2dev/icons
+ * @description PRO-28.4 — Icon Preview Component
+ *
+ * Advanced icon preview with:
+ * - Grid view
+ * - Dark/light mode preview
+ * - Size comparison
+ * - Animation preview
+ */
+import React, { type ComponentType } from 'react';
+import type { NtdIconProps } from './types';
+export type PreviewMode = 'light' | 'dark' | 'both' | 'gradient';
+export type PreviewLayout = 'grid' | 'list' | 'comparison';
+export interface PreviewSize {
+    label: string;
+    size: number;
+}
+export interface NiceIconPreviewProps {
+    /** Icon component to preview */
+    icon: ComponentType<NtdIconProps>;
+    /** Icon name for display */
+    iconName?: string;
+    /** Preview mode */
+    mode?: PreviewMode;
+    /** Layout */
+    layout?: PreviewLayout;
+    /** Custom sizes to show */
+    sizes?: PreviewSize[];
+    /** Show animation preview */
+    showAnimation?: boolean;
+    /** Available animations */
+    animations?: {
+        name: string;
+        className: string;
+    }[];
+    /** Fill color */
+    fill?: string;
+    /** Custom class */
+    className?: string;
+}
+/**
+ * Icon preview component with multiple modes and sizes.
+ */
+export declare function NiceIconPreview({ icon: Icon, iconName, mode, layout, sizes, showAnimation, animations, fill, className, }: NiceIconPreviewProps): React.ReactElement;
+export default NiceIconPreview;

package/dist/types/NiceIconSetCreator.d.ts

@@ -0,0 +1,97 @@
+/**
+ * @file NiceIconSetCreator.tsx
+ * @module @nice2dev/icons
+ * @description PRO-28.4 — Icon Set Creator Component
+ *
+ * Tool for creating custom icon sets from the icon library:
+ * - Select icons for project
+ * - Custom naming
+ * - TypeScript types generation
+ * - Tree-shaking friendly export
+ */
+import React, { type ComponentType } from 'react';
+import type { NtdIconProps } from './types';
+import type { IconMetadata } from './iconMetadata';
+export interface IconSetItem {
+    /** Original icon name */
+    originalName: string;
+    /** Custom name for the set */
+    customName: string;
+    /** Icon component */
+    icon: ComponentType<NtdIconProps>;
+    /** Icon metadata */
+    metadata?: IconMetadata;
+    /** Include in export */
+    included: boolean;
+}
+export interface IconSetConfig {
+    /** Set name (e.g., 'MyProjectIcons') */
+    name: string;
+    /** Package name for export */
+    packageName: string;
+    /** Description */
+    description: string;
+    /** Version */
+    version: string;
+    /** Author */
+    author: string;
+    /** License */
+    license: string;
+    /** Export format */
+    format: 'esm' | 'cjs' | 'both';
+    /** Generate TypeScript types */
+    generateTypes: boolean;
+    /** Include metadata in export */
+    includeMetadata: boolean;
+    /** Tree-shaking friendly (individual exports) */
+    treeShaking: boolean;
+}
+export type ExportOutput = {
+    filename: string;
+    content: string;
+    type: 'ts' | 'js' | 'json' | 'd.ts';
+};
+export interface NiceIconSetCreatorProps {
+    /** Available icons to choose from */
+    icons: {
+        name: string;
+        icon: ComponentType<NtdIconProps>;
+        metadata?: IconMetadata;
+    }[];
+    /** Initial selected icons */
+    initialSelection?: string[];
+    /** Default config */
+    defaultConfig?: Partial<IconSetConfig>;
+    /** Called when selection changes */
+    onSelectionChange?: (selection: IconSetItem[]) => void;
+    /** Called on export */
+    onExport?: (output: ExportOutput[]) => void;
+    /** Custom class */
+    className?: string;
+}
+export interface UseIconSetCreatorOptions {
+    icons: NiceIconSetCreatorProps['icons'];
+    initialSelection?: string[];
+    defaultConfig?: Partial<IconSetConfig>;
+}
+export interface UseIconSetCreatorReturn {
+    items: IconSetItem[];
+    config: IconSetConfig;
+    selectedCount: number;
+    toggleIcon: (name: string) => void;
+    selectAll: () => void;
+    deselectAll: () => void;
+    renameIcon: (originalName: string, newName: string) => void;
+    updateConfig: (updates: Partial<IconSetConfig>) => void;
+    generateExport: () => ExportOutput[];
+    getSelectedItems: () => IconSetItem[];
+}
+/**
+ * Hook for managing icon set creator state.
+ */
+export declare function useIconSetCreator(options: UseIconSetCreatorOptions): UseIconSetCreatorReturn;
+/**
+ * Icon Set Creator component for building custom icon packages.
+ */
+export declare function NiceIconSetCreator({ icons, initialSelection, defaultConfig, onSelectionChange, onExport, className, }: NiceIconSetCreatorProps): React.ReactElement;
+export default NiceIconSetCreator;

package/dist/types/advancedIconSearch.d.ts

@@ -0,0 +1,218 @@
+/**
+ * @file advancedIconSearch.ts
+ * @module @nice2dev/icons
+ * @description PRO-28.3 — Advanced Icon Search with fuzzy matching,
+ * filters, semantic search support, and analytics.
+ */
+import type { IconCategory, IconMetadata } from './iconMetadata';
+/** Domain classification for icons */
+export type IconDomain = 'general' | 'finance' | 'healthcare' | 'education' | 'technology' | 'ecommerce' | 'social' | 'gaming' | 'media' | 'enterprise' | 'science' | 'travel' | 'food' | 'sports' | 'lifestyle';
+/** Use-case classification for icons */
+export type IconUseCase = 'cursor' | 'toolbar' | 'menu' | 'status' | 'notification' | 'indicator' | 'action' | 'navigation' | 'display' | 'avatar' | 'illustration' | 'badge' | 'decoration';
+/** Style classification */
+export type IconStyle = 'solid' | 'outline' | 'duotone' | 'flat' | 'gradient' | 'hand-drawn';
+/** Localized names for i18n */
+export interface LocalizedNames {
+    en: string;
+    pl?: string;
+    de?: string;
+    es?: string;
+    fr?: string;
+    pt?: string;
+    it?: string;
+    ja?: string;
+    zh?: string;
+    ko?: string;
+    ru?: string;
+    ar?: string;
+    [key: string]: string | undefined;
+}
+/** Extended icon metadata with advanced tagging */
+export interface ExtendedIconMetadata extends IconMetadata {
+    /** Primary category */
+    primaryCategory: IconCategory;
+    /** Secondary categories */
+    secondaryCategories: IconCategory[];
+    /** Domain classification */
+    domains: IconDomain[];
+    /** Use-case classification */
+    useCases: IconUseCase[];
+    /** Compatible styles */
+    styles: IconStyle[];
+    /** Recommended size range [min, max] */
+    recommendedSizes: [number, number];
+    /** Closely related icons */
+    relatedIcons: string[];
+    /** Alternative names / aliases */
+    aliases: string[];
+    /** Localized display names */
+    localizedNames: LocalizedNames;
+    /** Keywords for search optimization */
+    searchKeywords: string[];
+    /** Date added to library */
+    dateAdded?: string;
+    /** Version when added */
+    versionAdded?: string;
+    /** Is the icon deprecated? */
+    deprecated?: boolean;
+    /** Deprecated message / replacement */
+    deprecatedMessage?: string;
+}
+/** Advanced search filters */
+export interface AdvancedSearchFilters {
+    /** Filter by categories */
+    categories?: IconCategory[];
+    /** Filter by domains */
+    domains?: IconDomain[];
+    /** Filter by use cases */
+    useCases?: IconUseCase[];
+    /** Filter by available styles */
+    styles?: IconStyle[];
+    /** Filter by minimum size */
+    minSize?: number;
+    /** Filter by maximum size */
+    maxSize?: number;
+    /** Only recent icons (days) */
+    recentDays?: number;
+    /** Exclude deprecated */
+    excludeDeprecated?: boolean;
+    /** Only favorites */
+    favoritesOnly?: boolean;
+    /** Only recently used */
+    recentlyUsedOnly?: boolean;
+}
+/** Search result with match metadata */
+export interface AdvancedSearchResult {
+    /** Icon name/ID */
+    name: string;
+    /** Extended metadata */
+    metadata: ExtendedIconMetadata;
+    /** Match score (0-100) */
+    score: number;
+    /** What matched */
+    matchedIn: ('name' | 'alias' | 'tag' | 'description' | 'keyword' | 'localized')[];
+    /** Highlighted text snippets */
+    highlights: {
+        field: string;
+        text: string;
+    }[];
+}
+/** Search analytics data */
+export interface SearchAnalytics {
+    /** Search query */
+    query: string;
+    /** Time taken (ms) */
+    duration: number;
+    /** Total results */
+    totalResults: number;
+    /** Filters applied */
+    filters: AdvancedSearchFilters;
+    /** Timestamp */
+    timestamp: number;
+}
+/**
+ * Calculate Levenshtein distance between two strings.
+ */
+export declare function levenshteinDistance(a: string, b: string): number;
+/**
+ * Calculate fuzzy match score (0-100).
+ */
+export declare function fuzzyMatchScore(query: string, target: string): number;
+/**
+ * Tokenize a search query.
+ */
+export declare function tokenizeQuery(query: string): string[];
+/**
+ * Register an icon with extended metadata.
+ */
+export declare function registerExtendedIcon(name: string, metadata: Partial<ExtendedIconMetadata>): void;
+/**
+ * Get extended metadata for an icon.
+ */
+export declare function getExtendedMetadata(name: string): ExtendedIconMetadata | undefined;
+/**
+ * Mark an icon as favorite.
+ */
+export declare function toggleFavorite(name: string): boolean;
+/**
+ * Check if icon is favorite.
+ */
+export declare function isFavorite(name: string): boolean;
+/**
+ * Get all favorite icons.
+ */
+export declare function getFavorites(): string[];
+/**
+ * Record icon usage (for analytics).
+ */
+export declare function recordIconUsage(name: string): void;
+/**
+ * Get recently used icons.
+ */
+export declare function getRecentlyUsed(limit?: number): string[];
+/**
+ * Perform advanced search with fuzzy matching and filters.
+ */
+export declare function advancedSearch(query: string, filters?: AdvancedSearchFilters, options?: {
+    maxResults?: number;
+    minScore?: number;
+    locale?: string;
+}): AdvancedSearchResult[];
+/**
+ * Find similar icons based on metadata overlap.
+ */
+export declare function findSimilarIcons(iconName: string, limit?: number): {
+    name: string;
+    similarity: number;
+}[];
+/**
+ * Get search suggestions based on partial input.
+ */
+export declare function getSearchSuggestions(partial: string, limit?: number): string[];
+/**
+ * Get search analytics summary.
+ */
+export declare function getSearchAnalytics(): {
+    totalSearches: number;
+    averageDuration: number;
+    topQueries: {
+        query: string;
+        count: number;
+    }[];
+    zeroResultQueries: string[];
+};
+/**
+ * Get icon usage statistics.
+ */
+export declare function getIconUsageStats(): {
+    mostUsed: {
+        name: string;
+        count: number;
+    }[];
+    leastUsed: string[];
+    neverUsed: string[];
+};
+/**
+ * Clear search history.
+ */
+export declare function clearSearchHistory(): void;
+/**
+ * Clear recently used.
+ */
+export declare function clearRecentlyUsed(): void;
+export interface UseAdvancedSearchReturn {
+    query: string;
+    setQuery: (query: string) => void;
+    filters: AdvancedSearchFilters;
+    setFilters: React.Dispatch<React.SetStateAction<AdvancedSearchFilters>>;
+    results: AdvancedSearchResult[];
+    isSearching: boolean;
+    suggestions: string[];
+    search: () => void;
+    clearFilters: () => void;
+}
+/**
+ * React hook for advanced icon search.
+ */
+export declare function useAdvancedIconSearch(debounceMs?: number, locale?: string): UseAdvancedSearchReturn;
+export default advancedSearch;