@nice2dev/ui-graphics 1.0.0

package/dist/types/game/useGameAssetEditor.d.ts

@@ -0,0 +1,79 @@
+/**
+ * useGameAssetEditor.ts — State and logic hook for GameAsset2dEditor
+ */
+import type { GameAssetProject, SpriteFrame, SpriteAnimation, AnimationState, AnimationParameter, Effect, EditorState, EditorMode, TileMapTool, SpriteSheetTool } from './gameAssetTypes';
+export interface UseGameAssetEditorOptions {
+    onSave?: (project: GameAssetProject) => void;
+    onExport?: (data: string, format: string) => void;
+}
+export interface GameAssetEditorApi {
+    project: GameAssetProject;
+    setProject: (project: GameAssetProject) => void;
+    newProject: (name: string) => void;
+    saveProject: () => void;
+    loadProject: (file: File) => Promise<void>;
+    editorState: EditorState;
+    setMode: (mode: EditorMode) => void;
+    setTileMapTool: (tool: TileMapTool) => void;
+    setSpriteSheetTool: (tool: SpriteSheetTool) => void;
+    setZoom: (zoom: number) => void;
+    setPan: (x: number, y: number) => void;
+    toggleGrid: () => void;
+    toggleCollision: () => void;
+    toggleSnap: () => void;
+    addTile: (imageData: ImageData, name: string) => void;
+    removeTile: (id: string) => void;
+    selectTile: (id: string | null) => void;
+    importTileSet: (file: File) => Promise<void>;
+    createTileMap: (name: string, width: number, height: number) => void;
+    removeTileMap: (id: string) => void;
+    selectTileMap: (id: string | null) => void;
+    setTile: (layerId: string, x: number, y: number, tileId: string | null) => void;
+    fillTiles: (layerId: string, x: number, y: number, tileId: string | null) => void;
+    addLayer: () => void;
+    removeLayer: (id: string) => void;
+    selectLayer: (id: string | null) => void;
+    toggleLayerVisibility: (id: string) => void;
+    setLayerOpacity: (id: string, opacity: number) => void;
+    moveLayer: (id: string, direction: 'up' | 'down') => void;
+    importSpriteSheet: (file: File) => Promise<void>;
+    removeSpriteSheet: (id: string) => void;
+    selectSpriteSheet: (id: string | null) => void;
+    autoSlice: (frameWidth: number, frameHeight: number) => void;
+    detectSprites: () => void;
+    addFrame: (frame: Omit<SpriteFrame, 'id'>) => void;
+    updateFrame: (id: string, updates: Partial<SpriteFrame>) => void;
+    removeFrame: (id: string) => void;
+    selectFrames: (ids: string[]) => void;
+    createAnimation: (name: string, frameIds: string[]) => void;
+    removeAnimation: (id: string) => void;
+    updateAnimation: (id: string, updates: Partial<SpriteAnimation>) => void;
+    createStateMachine: (name: string) => void;
+    removeStateMachine: (id: string) => void;
+    selectStateMachine: (id: string | null) => void;
+    addState: (name: string, animationId: string) => void;
+    removeState: (id: string) => void;
+    selectState: (id: string | null) => void;
+    updateState: (id: string, updates: Partial<AnimationState>) => void;
+    addTransition: (fromId: string, toId: string) => void;
+    removeTransition: (id: string) => void;
+    addParameter: (name: string, type: AnimationParameter['type']) => void;
+    removeParameter: (id: string) => void;
+    addEffect: (type: Effect['type']) => void;
+    removeEffect: (id: string) => void;
+    updateEffect: (id: string, updates: Partial<Effect>) => void;
+    toggleEffect: (id: string) => void;
+    saveEffectPreset: (name: string) => void;
+    loadEffectPreset: (id: string) => void;
+    previewEffects: (imageData: ImageData) => ImageData;
+    undo: () => void;
+    redo: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+    exportTileMap: (format: 'json' | 'tiled-json' | 'png') => void;
+    exportSpriteSheet: (format: 'json' | 'png' | 'atlas') => void;
+    exportStateMachine: (format: 'json') => void;
+    canvasRef: React.RefObject<HTMLCanvasElement>;
+    fileInputRef: React.RefObject<HTMLInputElement>;
+}
+export declare const useGameAssetEditor: (options?: UseGameAssetEditorOptions) => GameAssetEditorApi;

package/dist/types/game/useGameAssetExport.d.ts

@@ -0,0 +1,82 @@
+/**
+ * useGameAssetExport
+ * Hook for exporting game assets from editor contexts
+ */
+import type { ExportFormat, ExportResult, ExportManagerOptions } from './gameAssetExport';
+import type { CollisionShape } from './CollisionEditor';
+export interface UseGameAssetExportOptions {
+    /** Asset name */
+    name: string;
+    /** Asset dimensions */
+    width: number;
+    height: number;
+    /** Image data (canvas, blob, or path) */
+    image: HTMLCanvasElement | Blob | string;
+    /** Collision shapes */
+    collisions?: CollisionShape[];
+    /** Animation frames data */
+    frames?: FrameData[];
+    /** Default export format */
+    defaultFormat?: ExportFormat;
+}
+export interface FrameData {
+    /** Frame index */
+    index: number;
+    /** Frame duration in ms */
+    duration: number;
+    /** Frame region in source image */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Anchor point (0-1) */
+    anchorX?: number;
+    anchorY?: number;
+    /** Per-frame collisions */
+    collisions?: CollisionShape[];
+}
+export interface ExportState {
+    /** Whether export is in progress */
+    isExporting: boolean;
+    /** Export progress (0-1) */
+    progress: number;
+    /** Current export step */
+    step: string;
+    /** Last export results */
+    results: ExportResult[] | null;
+    /** Last export error */
+    error: Error | null;
+}
+export interface UseGameAssetExportReturn {
+    /** Export state */
+    state: ExportState;
+    /** Export to specific format */
+    exportTo: (format: ExportFormat, options?: Partial<ExportManagerOptions['formatOptions']>) => Promise<ExportResult[]>;
+    /** Export and download */
+    exportAndDownload: (format: ExportFormat, options?: Partial<ExportManagerOptions['formatOptions']>) => Promise<void>;
+    /** Export and download as ZIP */
+    exportAndZip: (format: ExportFormat, options?: Partial<ExportManagerOptions['formatOptions']>) => Promise<void>;
+    /** Export to all formats */
+    exportAll: () => Promise<Map<ExportFormat, ExportResult[]>>;
+    /** Clear last results/error */
+    reset: () => void;
+    /** Available formats */
+    availableFormats: ExportFormat[];
+}
+export declare function useGameAssetExport(options: UseGameAssetExportOptions): UseGameAssetExportReturn;
+export interface ExportWithImageOptions extends UseGameAssetExportOptions {
+    /** Include image in export */
+    includeImage?: boolean;
+    /** Image format */
+    imageFormat?: 'png' | 'webp' | 'jpg';
+    /** Image quality (0-1, for jpg/webp) */
+    imageQuality?: number;
+}
+/**
+ * Export asset data along with image file
+ */
+export declare function exportWithImage(format: ExportFormat, options: ExportWithImageOptions): Promise<{
+    data: ExportResult[];
+    image?: Blob;
+}>;
+export default useGameAssetExport;

package/dist/types/icon/NiceIconEditor.d.ts

@@ -0,0 +1,79 @@
+/**
+ * NiceIconEditor.tsx — SVG icon editor integrated with @nice2dev/icons.
+ *
+ * Features:
+ * - SVG icon creation and editing (paths, shapes)
+ * - Grid-aligned design (24×24, 32×32, 48×48 grids)
+ * - Outline/filled style variants
+ * - Stroke width and cap adjustments
+ * - Export to SVG, React component, PNG (multiple sizes)
+ * - Icon set management
+ * - Preview on different backgrounds
+ */
+import React from "react";
+export interface IconEditorProps {
+    /** Initial SVG content. */
+    initialSvg?: string;
+    /** Grid size in px. Default: 24. */
+    gridSize?: number;
+    /** Called on save with SVG string. */
+    onSave?: (svg: string) => void;
+    /** Called on export. */
+    onExport?: (data: IconExportResult) => void;
+    /** CSS class. */
+    className?: string;
+}
+export interface IconConfig {
+    viewBox: number;
+    strokeWidth: number;
+    strokeLinecap: "butt" | "round" | "square";
+    strokeLinejoin: "miter" | "round" | "bevel";
+    fill: string;
+    stroke: string;
+    variant: "outline" | "filled" | "duotone";
+}
+export interface IconShape {
+    id: string;
+    type: "path" | "circle" | "rect" | "line" | "polyline" | "polygon";
+    d?: string;
+    cx?: number;
+    cy?: number;
+    r?: number;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    x1?: number;
+    y1?: number;
+    x2?: number;
+    y2?: number;
+    points?: string;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+}
+export interface IconExportResult {
+    svg: string;
+    reactComponent: string;
+    pngSizes: Map<number, Blob>;
+}
+export type IconVariant = "outline" | "filled" | "duotone";
+export interface IconEditorApi {
+    config: IconConfig;
+    setConfig: React.Dispatch<React.SetStateAction<IconConfig>>;
+    shapes: IconShape[];
+    setShapes: React.Dispatch<React.SetStateAction<IconShape[]>>;
+    selectedId: string | null;
+    setSelectedId: React.Dispatch<React.SetStateAction<string | null>>;
+    tool: "select" | "path" | "circle" | "rect" | "line";
+    setTool: React.Dispatch<React.SetStateAction<"select" | "path" | "circle" | "rect" | "line">>;
+    addShape: (shape: Omit<IconShape, "id">) => void;
+    updateShape: (id: string, updates: Partial<IconShape>) => void;
+    deleteShape: (id: string) => void;
+    toSvg: () => string;
+    toReactComponent: (name: string) => string;
+}
+export declare function useIconEditor(initialSvg?: string): IconEditorApi;
+/** SVG icon editor with grid, snap, and export capabilities. */
+export declare const NiceIconEditor: React.FC<IconEditorProps>;
+export default NiceIconEditor;

package/dist/types/index.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @nice2dev/ui-graphics — Public API
+ *
+ * Tree-shakeable exports. Import only what you need:
+ *   import { PixelEditor } from '@nice2dev/ui-graphics';
+ *   import { NiceI18nProvider } from '@nice2dev/ui-graphics';
+ */
+export { PixelEditor, type PixelEditorProps } from './pixel/PixelEditor';
+export { VectorEditor, type VectorEditorProps } from './vector/VectorEditor';
+export { default as PhotoEditor } from './photo/PhotoEditor';
+export type { PhotoEditorProps } from './photo/photoEditorTypes';
+export { AnimationEditor, type AnimationEditorProps } from './animation/AnimationEditor';
+export { default as AnimatedPerson, type AnimatedPersonProps } from './animation/AnimatedPerson';
+export { GameAsset2dEditor, type GameAsset2dEditorProps, useGameAssetEditor, type GameAssetEditorApi, } from './game';
+export type { TileMap, TileLayer, TileDefinition, SpriteSheet, SpriteFrame, SpriteAnimation, AnimationStateMachine, AnimationState, AnimationTransition, GameAssetProject, Effect, EffectType, } from './game';
+export { NiceI18nProvider, useNiceTranslation, type NiceTranslateFn, type NiceI18nProviderProps, } from './core/i18n';
+export type { Layer, Tool as PixelTool, BlendMode } from './pixel/pixelEditorTypes';
+export { ditherOrdered, ditherFloydSteinberg, ditherAtkinson, applyDithering, extractPalette, hexPaletteToRGBA, createReferenceOverlay, renderReferenceOverlay, type DitheringAlgorithm, type ReferenceOverlay, } from './pixel/pixelEditorUtils';
+export { exportGIF, exportSpriteSheetAdvanced, } from './pixel/pixelEditorExports';
+export type { VShape, VTool as VectorTool } from './vector/vectorEditorTypes';
+export { booleanOperation, shapesOverlap, flattenToOutline, type BooleanOp, } from './vector/vectorBooleanOps';
+export { PRESET_GRADIENTS, gradientToCSS, gradientToSVGDef, createLinearGradient, createRadialGradient, type Gradient, type LinearGradient, type RadialGradient, type GradientStop, } from './vector/vectorGradients';
+export type { AdjustmentValues, FilterParams } from './photo/photoFilters';
+export { magicWandSelect, lassoSelect, magneticLassoPoint, selectColorRange, applyHealingBrush, contentAwareFill, renderSelectionOutline, createEmptyMask, featherMask, invertMask, combineMasks, type SelectionMask, type MagicWandOptions, type HealingBrushOptions, type SelectionMode, } from './photo/photoSelection';
+export type { CharacterConfig, FeatureConfig } from './animation/characterTypes';
+export { VARIANTS, DEFAULT_CHARACTER, DEFAULT_COLORS, pick } from './animation/characterTypes';
+export type { PersonPose, ChoreoStep as AnimChoreoStep } from './animation/animationHelper';
+export { playPose, runChoreo, usePersonControls } from './animation/animationHelper';
+export type { BoneKey, BoneSpec, RigConfig, RigPose, SolvedBone } from './animation/rig/rigTypes';
+export { BONE_ORDER, DEFAULT_RIG, DEFAULT_POSE } from './animation/rig/rigTypes';
+export { solveTwoBoneIK } from './animation/rig/ik';
+export { deg2rad, lerpAngle, solveFK } from './animation/rig/rigMath';
+export { blendPose, tweenPose, ease } from './animation/rig/poseOps';
+export { RIG_SLIM, RIG_HERO, RIG_ROBOT, POSE_HAPPY, POSE_ANGRY, POSE_DANCE_A } from './animation/rig/presets';
+export { default as RiggedBody } from './animation/rig/RiggedBody';
+export { default as RigPlayer } from './animation/rig/RigPlayer';
+export type { RigPlayerHandle } from './animation/rig/RigPlayer';
+export { rigPoseFor, playRigFromChoreo } from './animation/rig/choreoRigBridge';
+export { ChoreoBuilder, seq, compile, runSeq, runWave, runCannon, runRounds } from './animation/choreoDSL';
+export { waveScoreChoreo, booChoreo, danceParty, showcaseAll } from './animation/choreography';
+export { default as Audience } from './animation/Audience';
+export type { AudienceProps } from './animation/Audience';
+export { scoreBus, onScore, reactionForScore, playIntro, simulateScore, attachScoreReactions, } from './animation/karaokeIntegration';
+export { BodyRenderer, default as BodyRendererDefault } from './animation/BodyRenderer';
+export type { BodyRendererProps } from './animation/BodyRenderer';
+export { Head, HEAD_RENDERERS } from './animation/shapes/heads';
+export type { HeadProps } from './animation/shapes/heads';
+export { Eyes, EYES_RENDERERS } from './animation/shapes/eyes';
+export type { EyesProps } from './animation/shapes/eyes';
+export { Nose, NOSE_RENDERERS } from './animation/shapes/noses';
+export type { NoseProps } from './animation/shapes/noses';
+export { Mouth, MOUTH_RENDERERS } from './animation/shapes/mouths';
+export type { MouthProps } from './animation/shapes/mouths';
+export { Hair, HAIR_RENDERERS } from './animation/shapes/hair';
+export type { HairProps } from './animation/shapes/hair';
+export { Outfit, OUTFIT_RENDERERS } from './animation/shapes/outfits';
+export type { OutfitProps } from './animation/shapes/outfits';
+export { Torso } from './animation/shapes/torsos';
+export type { TorsoProps } from './animation/shapes/torsos';
+export { Arm } from './animation/shapes/arms';
+export type { ArmProps } from './animation/shapes/arms';
+export { Leg } from './animation/shapes/legs';
+export type { LegProps } from './animation/shapes/legs';
+export { Headwear, HEADWEAR_RENDERERS } from './animation/shapes/headwear';
+export type { HeadwearProps } from './animation/shapes/headwear';
+export { createRagdoll, stepRagdoll, ragdollToPose, applyImpulse, createCloth, stepCloth, clothVertices, pinClothParticle, type PhysicsParticle, type DistanceConstraint, type RagdollConfig, type Ragdoll, type Cloth, } from './animation/physics';
+export { evaluatePath, evaluatePathTangent, pathLength, arcLengthTable, distanceToT, createLinearPath, createCircularPath, createFigure8Path, evaluateMotionPathAnimation, PRESET_PATHS, type MotionPath, type BezierPoint, type MotionPathKeyframe, type MotionPathAnimation, } from './animation/motionPath';
+export { exportToLottie, lottieToJSON, lottieToBlob, choreoToLottieKeyframes, } from './animation/lottieExport';
+export { exportToSpine, spineToJSON, spineToBlob, } from './animation/spineExport';
+export { PluginRegistry, NicePluginProvider, usePlugins, usePluginRegistry, type EditorPlugin, type PluginTool, type PluginFilter, type PluginExporter, type PluginPanel, type PluginMenuAction, } from './core/plugins';
+export { useVisualHistory, VisualHistoryPanel, type HistoryEntry, type VisualHistoryApi, } from './core/historyVisual';
+export { ShortcutRegistry, DEFAULT_SHORTCUTS, useShortcuts, eventToKeyCombo, type ShortcutDef, type ShortcutConfig, } from './core/shortcuts';
+export { useDragDrop, DropZoneOverlay, type DragDropConfig, type DropResult, type DragDropState, type DropZoneOverlayProps, } from './core/dragDrop';
+export { NiceRTLProvider, useRTL, useIsRTL, logicalStyles, rtlFlexDirection, detectDirection, type Direction, type RTLConfig, } from './core/rtl';
+export { Minimap, useMinimap, type MinimapProps, type MinimapConfig, type ViewportRect, } from './core/minimap';
+export { drawGrid, drawHorizontalRuler, drawVerticalRuler, drawGuides, snapToGrid, snapToGuides, snapToPixel, snapPoint, createGuide, addGuide, removeGuide, clearGuides, type GridConfig, type RulersConfig, type GuidesConfig, type Guide, type SnapResult, } from './core/gridGuides';
+export { simulateColorBlindness, simulateColorBlindnessCopy, applyColorBlindnessFilter, simulateColor, colorBlindnessSvgFilter, COLOR_BLINDNESS_TYPES, type ColorBlindnessType, type ColorBlindnessInfo, } from './core/colorBlindness';
+export { LIGHT_THEME, DARK_THEME, themeToCssVars, applyThemeToElement, systemPrefersDark, resolveThemeMode, NiceEditorThemeProvider, useEditorTheme, type EditorTheme, type ThemeMode, } from './core/theme';
+export { NiceIconEditor, useIconEditor, type IconShape, type IconVariant, type IconEditorApi, } from './icon/NiceIconEditor';
+export { NiceUIDesigner, useUIDesigner, exportToReact, type UINode, type UIDesignerApi, } from './ui/NiceUIDesigner';
+export { Nice3DTexturePainter, useTexturePainter, type TextureLayer, type BrushSettings, type TexturePainterApi, } from './texture/Nice3DTexturePainter';
+export { NiceFontEditor, useFontEditor, exportToSvgFont, type FontGlyph, type FontMetrics, type FontEditorApi, } from './font/NiceFontEditor';
+export { UnsplashProvider, PexelsProvider, AdobeCCConnector, FigmaConnector, TemplateLibrary, generateAIImage, type StockImage, type StockImageSearchOptions, type FigmaImportResult, type FigmaNode, type AIGenerationOptions, type AIGenerationResult, type TemplateItem, type AdobeCCConfig, } from './core/integrations';
+export { WebSocketTransport, VersionHistory, CommentManager, useCollaboration, useComments, useVersionHistory, type CollaborationUser, type CollaborationOperation, type CollaborationTransport, type CollaborationMessage, type Comment, type CommentReply, type VersionSnapshot, } from './core/collaboration';
+export { setupRetinaCanvas, retinaMousePosition, virtualizeShapes, SpatialHashGrid, AnimationCleanup, type RetinaCanvasOptions, type VirtualBounds, type VirtualizedShape, } from './core/fixes';

package/dist/types/photo/BatchProcessingPanel.d.ts

@@ -0,0 +1,13 @@
+/**
+ * BatchProcessingPanel
+ * UI panel for batch processing in PhotoEditor
+ */
+import React from 'react';
+export interface BatchProcessingPanelProps {
+    /** Called when processing complete */
+    onComplete?: () => void;
+    /** Custom class name */
+    className?: string;
+}
+export declare const BatchProcessingPanel: React.FC<BatchProcessingPanelProps>;
+export default BatchProcessingPanel;

package/dist/types/photo/FaceDetectionPanel.d.ts

@@ -0,0 +1,18 @@
+/**
+ * FaceDetectionPanel — UI for face detection and auto-crop
+ */
+import { FaceRegion } from './faceDetection';
+export interface FaceDetectionPanelProps {
+    /** Source image data */
+    imageData: ImageData | null;
+    /** Callback when crop is applied */
+    onCrop: (x: number, y: number, width: number, height: number) => void;
+    /** Callback when face regions are detected */
+    onFacesDetected?: (faces: FaceRegion[]) => void;
+    /** Optional class name */
+    className?: string;
+    /** Panel title */
+    title?: string;
+}
+export declare function FaceDetectionPanel({ imageData, onCrop, onFacesDetected, className, title, }: FaceDetectionPanelProps): import("react/jsx-runtime").JSX.Element;
+export default FaceDetectionPanel;

package/dist/types/photo/FilterThumb.d.ts

@@ -0,0 +1,14 @@
+/**
+ * FilterThumb — Thumbnail preview for a photo filter.
+ */
+import React from "react";
+import type { FilterDefinition } from "./photoFilters";
+interface Props {
+    filter: FilterDefinition;
+    selected: boolean;
+    accent: string;
+    onSelect: () => void;
+    generateThumbnail: (canvas: HTMLCanvasElement, filter: FilterDefinition) => void;
+}
+declare const FilterThumb: React.FC<Props>;
+export default FilterThumb;

package/dist/types/photo/PerspectiveCorrectionPanel.d.ts

@@ -0,0 +1,17 @@
+/**
+ * PerspectiveCorrectionPanel
+ * UI panel for perspective correction in PhotoEditor
+ */
+import React from 'react';
+export interface PerspectiveCorrectionPanelProps {
+    /** Source image data */
+    imageData: ImageData;
+    /** Called when correction is applied */
+    onApply: (result: ImageData) => void;
+    /** Called when cancelled */
+    onCancel?: () => void;
+    /** Custom class name */
+    className?: string;
+}
+export declare const PerspectiveCorrectionPanel: React.FC<PerspectiveCorrectionPanelProps>;
+export default PerspectiveCorrectionPanel;

package/dist/types/photo/PhotoEditor.d.ts

@@ -0,0 +1,2 @@
+import type { PhotoEditorProps } from "./photoEditorTypes";
+export default function PhotoEditor(props: PhotoEditorProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/photo/PhotoEditorCanvas.d.ts

@@ -0,0 +1,14 @@
+/**
+ * PhotoEditorCanvas.tsx — Canvas viewport for the PhotoEditor.
+ *
+ * Shows either:
+ *  - Compare mode (before / after with a slider)
+ *  - Regular mode (main canvas + optional crop overlay)
+ */
+import React from "react";
+import type { PhotoEditorAPI } from "./usePhotoEditor";
+interface Props {
+    api: PhotoEditorAPI;
+}
+declare const PhotoEditorCanvas: React.FC<Props>;
+export default PhotoEditorCanvas;

package/dist/types/photo/PhotoEditorLeftPanel.d.ts

@@ -0,0 +1,13 @@
+/**
+ * PhotoEditorLeftPanel.tsx — Left sidebar of the PhotoEditor.
+ *
+ * Contains 8 tab buttons and their corresponding panel content:
+ *   Filters, Adjust, Crop, Transform, Stickers, Text, Shapes, Draw
+ */
+import React from "react";
+import type { PhotoEditorAPI } from "./usePhotoEditor";
+interface Props {
+    api: PhotoEditorAPI;
+}
+declare const PhotoEditorLeftPanel: React.FC<Props>;
+export default PhotoEditorLeftPanel;

package/dist/types/photo/PhotoEditorToolbar.d.ts

@@ -0,0 +1,13 @@
+/**
+ * PhotoEditorToolbar.tsx — Top toolbar for the PhotoEditor.
+ *
+ * Includes undo / redo / reset, compare toggle, download / clipboard / share,
+ * title, cancel and save (apply) buttons.
+ */
+import React from "react";
+import type { PhotoEditorAPI } from "./usePhotoEditor";
+interface Props {
+    api: PhotoEditorAPI;
+}
+declare const PhotoEditorToolbar: React.FC<Props>;
+export default PhotoEditorToolbar;

package/dist/types/photo/RawFilePanel.d.ts

@@ -0,0 +1,14 @@
+/**
+ * RawFilePanel — UI for RAW file loading and processing
+ */
+import { RawMetadata } from './rawFileSupport';
+export interface RawFilePanelProps {
+    /** Callback when RAW file is processed */
+    onLoad: (imageData: ImageData, metadata: RawMetadata) => void;
+    /** Optional class name */
+    className?: string;
+    /** Panel title */
+    title?: string;
+}
+export declare function RawFilePanel({ onLoad, className, title, }: RawFilePanelProps): import("react/jsx-runtime").JSX.Element;
+export default RawFilePanel;

package/dist/types/photo/StyleTransferPanel.d.ts

@@ -0,0 +1,15 @@
+/**
+ * StyleTransferPanel — UI for AI-based style transfer
+ */
+export interface StyleTransferPanelProps {
+    /** Source image data */
+    imageData: ImageData | null;
+    /** Callback when style transfer is applied */
+    onApply: (result: ImageData) => void;
+    /** Optional class name */
+    className?: string;
+    /** Panel title */
+    title?: string;
+}
+export declare function StyleTransferPanel({ imageData, onApply, className, title, }: StyleTransferPanelProps): import("react/jsx-runtime").JSX.Element;
+export default StyleTransferPanel;

package/dist/types/photo/aiStyleTransfer.d.ts

@@ -0,0 +1,58 @@
+/**
+ * aiStyleTransfer — AI-based style transfer filters for PhotoEditor
+ *
+ * This module implements neural style transfer effects using pure canvas operations
+ * for lightweight, dependency-free artistic filters. Also supports optional
+ * TensorFlow.js integration for more advanced neural style transfer.
+ *
+ * Features:
+ * - Pre-defined artistic styles (oil painting, watercolor, sketch, etc.)
+ * - Real-time preview with downscaled processing
+ * - Adjustable style intensity
+ * - Optional TF.js for advanced neural transfer
+ */
+export type StylePreset = 'oil-painting' | 'watercolor' | 'pencil-sketch' | 'charcoal' | 'impressionist' | 'pop-art' | 'vintage' | 'noir' | 'cyberpunk' | 'anime' | 'pixel-art' | 'mosaic' | 'pointillism' | 'stained-glass' | 'custom';
+export interface StyleTransferOptions {
+    /** Style preset to apply */
+    style: StylePreset;
+    /** Intensity of the effect (0-1) */
+    intensity: number;
+    /** Detail preservation (0-1) */
+    detailPreservation: number;
+    /** Color saturation adjustment (-1 to 1) */
+    saturation: number;
+    /** Custom style image (for 'custom' preset) */
+    customStyleImage?: ImageData;
+    /** Processing quality (affects speed vs quality) */
+    quality: 'fast' | 'balanced' | 'high';
+}
+export interface StyleTransferResult {
+    imageData: ImageData;
+    processingTimeMs: number;
+    style: StylePreset;
+}
+export declare const DEFAULT_STYLE_OPTIONS: StyleTransferOptions;
+export declare const STYLE_PRESETS: Record<StylePreset, {
+    name: string;
+    description: string;
+}>;
+/**
+ * Downscale image for faster preview processing
+ */
+export declare function downscaleForPreview(imageData: ImageData, quality: 'fast' | 'balanced' | 'high'): {
+    data: ImageData;
+    scale: number;
+};
+/**
+ * Upscale processed image back to original size
+ */
+export declare function upscaleFromPreview(imageData: ImageData, originalWidth: number, originalHeight: number): ImageData;
+/**
+ * Apply style transfer to an image
+ */
+export declare function applyStyleTransfer(imageData: ImageData, options?: Partial<StyleTransferOptions>): StyleTransferResult;
+/**
+ * Generate preview thumbnails for all styles
+ */
+export declare function generateStylePreviews(imageData: ImageData, size?: number): Promise<Map<StylePreset, ImageData>>;
+export default applyStyleTransfer;

package/dist/types/photo/batchProcessing.d.ts

@@ -0,0 +1,95 @@
+/**
+ * batchProcessing.ts
+ * Batch image processing utilities for PhotoEditor
+ */
+/** Image processing operation */
+export interface ProcessingOperation {
+    type: string;
+    params: Record<string, unknown>;
+}
+/** Single batch item */
+export interface BatchItem {
+    id: string;
+    file: File;
+    status: 'pending' | 'processing' | 'completed' | 'error';
+    progress: number;
+    result?: Blob;
+    error?: string;
+    preview?: string;
+}
+/** Batch processing settings */
+export interface BatchSettings {
+    /** Operations to apply */
+    operations: ProcessingOperation[];
+    /** Output format */
+    outputFormat: 'jpeg' | 'png' | 'webp';
+    /** Output quality (0-1) */
+    quality: number;
+    /** Resize settings */
+    resize?: {
+        enabled: boolean;
+        width: number;
+        height: number;
+        maintainAspect: boolean;
+        mode: 'fit' | 'fill' | 'stretch';
+    };
+    /** Naming pattern */
+    namingPattern: string;
+    /** Preserve metadata */
+    preserveMetadata: boolean;
+}
+/** Processing result */
+export interface BatchResult {
+    totalFiles: number;
+    completedFiles: number;
+    failedFiles: number;
+    totalTime: number;
+    results: BatchItem[];
+}
+/** Available filter types */
+export type FilterType = 'brightness' | 'contrast' | 'saturation' | 'hue' | 'grayscale' | 'sepia' | 'invert' | 'blur' | 'sharpen' | 'vignette' | 'exposure' | 'gamma' | 'temperature' | 'posterize' | 'noise';
+/** Filter presets */
+export interface FilterPreset {
+    name: string;
+    operations: ProcessingOperation[];
+}
+/**
+ * Apply single operation to image data
+ */
+export declare function applyOperation(imageData: ImageData, operation: ProcessingOperation): void;
+/**
+ * Process single image file
+ */
+export declare function processImage(file: File, settings: BatchSettings, onProgress?: (progress: number) => void): Promise<Blob>;
+/**
+ * Process multiple images in batch
+ */
+export declare function processBatch(files: File[], settings: BatchSettings, onItemProgress?: (itemId: string, progress: number) => void, onItemComplete?: (item: BatchItem) => void): Promise<BatchResult>;
+/**
+ * Generate output filename
+ */
+export declare function generateOutputFilename(original: string, pattern: string, index: number, format: string): string;
+/**
+ * Download all batch results as ZIP
+ */
+export declare function downloadBatchAsZip(result: BatchResult, settings: BatchSettings): Promise<void>;
+export declare const FILTER_PRESETS: FilterPreset[];
+export declare const DEFAULT_BATCH_SETTINGS: BatchSettings;
+export interface UseBatchProcessingOptions {
+    onComplete?: (result: BatchResult) => void;
+}
+export declare function useBatchProcessing(options?: UseBatchProcessingOptions): {
+    files: File[];
+    items: BatchItem[];
+    settings: BatchSettings;
+    setSettings: import("react").Dispatch<import("react").SetStateAction<BatchSettings>>;
+    isProcessing: boolean;
+    result: BatchResult | null;
+    addFiles: (newFiles: File[]) => void;
+    removeFile: (index: number) => void;
+    clearFiles: () => void;
+    addOperation: (operation: ProcessingOperation) => void;
+    removeOperation: (index: number) => void;
+    applyPreset: (preset: FilterPreset) => void;
+    process: () => Promise<void>;
+};