@nice2dev/ui-graphics 1.3.13 → 1.3.14

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

@@ -1,95 +0,0 @@
-/**
- * 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>;
-};

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

@@ -1,103 +0,0 @@
-/**
- * faceDetection — Face detection for auto-crop and photo analysis
- *
- * Provides face detection using:
- * 1. Pure JS skin-tone + edge detection heuristics (fast, no deps)
- * 2. Optional face-api.js integration (accurate, requires loading models)
- *
- * Features:
- * - Face region detection
- * - Face count estimation
- * - Auto-crop suggestions
- * - Face landmarks (with face-api.js)
- * - Expression detection (with face-api.js)
- */
-export interface FaceRegion {
-    /** Bounding box */
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** Detection confidence (0-1) */
-    confidence: number;
-    /** Face landmarks (if available) */
-    landmarks?: FaceLandmarks;
-    /** Estimated expression (if available) */
-    expression?: FaceExpression;
-}
-export interface FaceLandmarks {
-    leftEye: {
-        x: number;
-        y: number;
-    };
-    rightEye: {
-        x: number;
-        y: number;
-    };
-    nose: {
-        x: number;
-        y: number;
-    };
-    mouthLeft: {
-        x: number;
-        y: number;
-    };
-    mouthRight: {
-        x: number;
-        y: number;
-    };
-    jawOutline?: Array<{
-        x: number;
-        y: number;
-    }>;
-}
-export type FaceExpression = 'neutral' | 'happy' | 'sad' | 'angry' | 'fearful' | 'disgusted' | 'surprised';
-export interface FaceDetectionOptions {
-    /** Minimum face size (relative to image, 0-1) */
-    minFaceSize: number;
-    /** Maximum number of faces to detect */
-    maxFaces: number;
-    /** Detection quality */
-    quality: 'fast' | 'accurate';
-    /** Include landmarks detection */
-    detectLandmarks: boolean;
-    /** Include expression detection */
-    detectExpressions: boolean;
-}
-export interface FaceDetectionResult {
-    /** Detected faces */
-    faces: FaceRegion[];
-    /** Processing time in ms */
-    processingTimeMs: number;
-    /** Detection method used */
-    method: 'heuristic' | 'neural';
-}
-export interface AutoCropSuggestion {
-    /** Suggested crop rectangle */
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    /** Aspect ratio used */
-    aspectRatio: number;
-    /** Crop type */
-    type: 'portrait' | 'headshot' | 'group' | 'full';
-}
-export declare const DEFAULT_DETECTION_OPTIONS: FaceDetectionOptions;
-/**
- * Generate auto-crop suggestion based on detected faces
- */
-export declare function generateAutoCropSuggestion(faces: FaceRegion[], imageWidth: number, imageHeight: number, targetAspectRatio?: number): AutoCropSuggestion | null;
-/**
- * Generate multiple crop suggestions for common aspect ratios
- */
-export declare function generateMultipleCropSuggestions(faces: FaceRegion[], imageWidth: number, imageHeight: number): AutoCropSuggestion[];
-/**
- * Detect faces in an image
- */
-export declare function detectFaces(imageData: ImageData, options?: Partial<FaceDetectionOptions>): Promise<FaceDetectionResult>;
-/**
- * Quick face detection (always uses heuristic for speed)
- */
-export declare function detectFacesFast(imageData: ImageData, maxFaces?: number): FaceRegion[];
-export default detectFaces;

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

@@ -1,17 +0,0 @@
-export { default as NicePhotoEditor } from './PhotoEditor';
-export { usePhotoEditor } from './usePhotoEditor';
-export type * from './photoEditorTypes';
-export * from './photoFilters';
-export * from './photoOverlays';
-export * from './photoSelection';
-export * from './photoEditorActions';
-export { applyStyleTransfer, generateStylePreviews, downscaleForPreview, upscaleFromPreview, STYLE_PRESETS, DEFAULT_STYLE_OPTIONS, type StylePreset, type StyleTransferOptions, } from './aiStyleTransfer';
-export { StyleTransferPanel } from './StyleTransferPanel';
-export { loadRawFile, extractMetadata, extractPreview, isRawFile, detectFormatFromExtension, detectFormatFromHeader, RAW_EXTENSIONS, ALL_RAW_EXTENSIONS, DEFAULT_RAW_OPTIONS, type RawFormat, type RawMetadata, type RawProcessingOptions, type RawLoadResult, } from './rawFileSupport';
-export { RawFilePanel } from './RawFilePanel';
-export { detectFaces, detectFacesFast, generateAutoCropSuggestion, type FaceRegion, type FaceDetectionOptions, type AutoCropSuggestion, } from './faceDetection';
-export { FaceDetectionPanel } from './FaceDetectionPanel';
-export { applyPerspectiveTransform, computePerspectiveTransform, detectDocumentEdges, createRectQuad, getQuadBounds, isPointInQuad, getNearestCorner, moveQuadCorner, getQuadArea, identityMatrix, multiplyMatrices, invertMatrix, transformPoint, PERSPECTIVE_PRESETS, type Quad, type Matrix3x3, type PerspectiveSettings, type CornerHandle, type PerspectivePreset, type UsePerspectiveCorrectionOptions, } from './perspectiveCorrection';
-export { PerspectiveCorrectionPanel } from './PerspectiveCorrectionPanel';
-export * from './batchProcessing';
-export { BatchProcessingPanel } from './BatchProcessingPanel';

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

@@ -1,124 +0,0 @@
-/**
- * perspectiveCorrection.ts
- * Perspective correction and transformation utilities for PhotoEditor
- */
-/** 2D Point */
-export interface Point {
-    x: number;
-    y: number;
-}
-/** Quad defined by four corners */
-export interface Quad {
-    topLeft: Point;
-    topRight: Point;
-    bottomRight: Point;
-    bottomLeft: Point;
-}
-/** 3x3 Transformation matrix */
-export type Matrix3x3 = [number, number, number, number, number, number, number, number, number];
-/** Perspective correction settings */
-export interface PerspectiveSettings {
-    /** Source quad corners */
-    sourceQuad: Quad;
-    /** Target quad corners (usually rectangle) */
-    targetQuad: Quad;
-    /** Interpolation method */
-    interpolation: 'nearest' | 'bilinear' | 'bicubic';
-    /** Maintain aspect ratio */
-    maintainAspect: boolean;
-    /** Output width */
-    outputWidth: number;
-    /** Output height */
-    outputHeight: number;
-}
-/** Corner handle being dragged */
-export type CornerHandle = 'topLeft' | 'topRight' | 'bottomRight' | 'bottomLeft';
-/** Preset perspective correction */
-export interface PerspectivePreset {
-    name: string;
-    description: string;
-    sourceQuad: Quad;
-}
-/**
- * Create identity matrix
- */
-export declare function identityMatrix(): Matrix3x3;
-/**
- * Multiply two 3x3 matrices
- */
-export declare function multiplyMatrices(a: Matrix3x3, b: Matrix3x3): Matrix3x3;
-/**
- * Invert 3x3 matrix
- */
-export declare function invertMatrix(m: Matrix3x3): Matrix3x3 | null;
-/**
- * Transform point using matrix
- */
-export declare function transformPoint(p: Point, m: Matrix3x3): Point;
-/**
- * Calculate perspective transformation matrix from quad to quad
- */
-export declare function computePerspectiveTransform(src: Quad, dst: Quad): Matrix3x3;
-/**
- * Apply perspective transform to image data
- */
-export declare function applyPerspectiveTransform(sourceData: ImageData, settings: PerspectiveSettings): ImageData;
-/**
- * Create rectangle quad
- */
-export declare function createRectQuad(x: number, y: number, width: number, height: number): Quad;
-/**
- * Calculate bounding box of quad
- */
-export declare function getQuadBounds(quad: Quad): {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-/**
- * Check if point is inside quad
- */
-export declare function isPointInQuad(point: Point, quad: Quad): boolean;
-/**
- * Get nearest corner handle to point
- */
-export declare function getNearestCorner(point: Point, quad: Quad, threshold?: number): CornerHandle | null;
-/**
- * Move corner of quad
- */
-export declare function moveQuadCorner(quad: Quad, corner: CornerHandle, newPos: Point): Quad;
-/**
- * Calculate quad area
- */
-export declare function getQuadArea(quad: Quad): number;
-/**
- * Detect document/paper edges in image
- * Returns suggested quad corners
- */
-export declare function detectDocumentEdges(imageData: ImageData, options?: {
-    edgeThreshold?: number;
-    minArea?: number;
-}): Quad | null;
-/**
- * Perspective correction presets
- */
-export declare const PERSPECTIVE_PRESETS: PerspectivePreset[];
-export interface UsePerspectiveCorrectionOptions {
-    imageWidth: number;
-    imageHeight: number;
-}
-export declare function usePerspectiveCorrection(options: UsePerspectiveCorrectionOptions): {
-    sourceQuad: Quad;
-    setSourceQuad: import("react").Dispatch<import("react").SetStateAction<Quad>>;
-    interpolation: "nearest" | "bilinear" | "bicubic";
-    setInterpolation: import("react").Dispatch<import("react").SetStateAction<"nearest" | "bilinear" | "bicubic">>;
-    maintainAspect: boolean;
-    setMaintainAspect: import("react").Dispatch<import("react").SetStateAction<boolean>>;
-    activeCorner: CornerHandle | null;
-    setActiveCorner: import("react").Dispatch<import("react").SetStateAction<CornerHandle | null>>;
-    resetQuad: () => void;
-    moveCorner: (corner: CornerHandle, newPos: Point) => void;
-    applyPreset: (preset: PerspectivePreset) => void;
-    getSettings: () => PerspectiveSettings;
-};

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

@@ -1,124 +0,0 @@
-/**
- * rawFileSupport — RAW camera file support for PhotoEditor
- *
- * Provides loading and processing of RAW camera formats including:
- * - Canon (.CR2, .CR3, .CRW)
- * - Nikon (.NEF, .NRW)
- * - Sony (.ARW, .SRF, .SR2)
- * - Adobe (.DNG)
- * - Fujifilm (.RAF)
- * - Olympus (.ORF)
- * - Panasonic (.RW2)
- * - Pentax (.PEF, .DNG)
- * - And many more via embedded thumbnail or DCRaw emulation
- *
- * Features:
- * - Embedded preview extraction (fast)
- * - Full demosaic processing (with optional libraw.js)
- * - White balance adjustment
- * - Exposure compensation
- * - Highlight recovery
- * - Noise reduction
- */
-export type RawFormat = 'cr2' | 'cr3' | 'crw' | 'nef' | 'nrw' | 'arw' | 'srf' | 'sr2' | 'dng' | 'raf' | 'orf' | 'rw2' | 'pef' | 'raw' | '3fr' | 'fff' | 'iiq' | 'mrw' | 'x3f' | 'rwl' | 'srw' | 'unknown';
-export interface RawMetadata {
-    /** Camera maker */
-    make: string;
-    /** Camera model */
-    model: string;
-    /** Image width */
-    width: number;
-    /** Image height */
-    height: number;
-    /** ISO sensitivity */
-    iso: number;
-    /** Shutter speed (seconds) */
-    shutterSpeed: number;
-    /** Aperture (f-number) */
-    aperture: number;
-    /** Focal length (mm) */
-    focalLength: number;
-    /** Capture date */
-    dateTime: Date | null;
-    /** Orientation (EXIF) */
-    orientation: number;
-    /** Color temperature (K) */
-    colorTemperature: number;
-    /** Detected RAW format */
-    format: RawFormat;
-    /** Has embedded preview */
-    hasPreview: boolean;
-    /** Has embedded thumbnail */
-    hasThumbnail: boolean;
-}
-export interface RawProcessingOptions {
-    /** Use embedded preview instead of demosaic */
-    usePreview: boolean;
-    /** White balance mode */
-    whiteBalance: 'camera' | 'auto' | 'daylight' | 'cloudy' | 'shade' | 'tungsten' | 'fluorescent' | 'flash' | 'custom';
-    /** Custom color temperature (K) */
-    colorTemperature: number;
-    /** Custom tint (green-magenta) */
-    tint: number;
-    /** Exposure compensation (EV) */
-    exposure: number;
-    /** Highlight recovery (0-1) */
-    highlightRecovery: number;
-    /** Shadow recovery (0-1) */
-    shadowRecovery: number;
-    /** Noise reduction level (0-1) */
-    noiseReduction: number;
-    /** Chromatic aberration correction */
-    chromaticAberration: boolean;
-    /** Output color space */
-    colorSpace: 'sRGB' | 'AdobeRGB' | 'ProPhotoRGB';
-    /** Output bit depth */
-    bitDepth: 8 | 16;
-    /** Demosaic algorithm */
-    demosaicAlgorithm: 'bilinear' | 'VNG' | 'PPG' | 'AHD' | 'DCB';
-}
-export interface RawLoadResult {
-    /** Processed image data */
-    imageData: ImageData;
-    /** Raw file metadata */
-    metadata: RawMetadata;
-    /** Processing info */
-    processingInfo: {
-        method: 'preview' | 'thumbnail' | 'demosaic';
-        timeMs: number;
-        originalWidth: number;
-        originalHeight: number;
-    };
-}
-export declare const DEFAULT_RAW_OPTIONS: RawProcessingOptions;
-export declare const RAW_EXTENSIONS: Record<RawFormat, string[]>;
-export declare const ALL_RAW_EXTENSIONS: string[];
-/**
- * Detect RAW format from file extension
- */
-export declare function detectFormatFromExtension(filename: string): RawFormat;
-/**
- * Detect RAW format from file header
- */
-export declare function detectFormatFromHeader(buffer: ArrayBuffer): RawFormat;
-/**
- * Check if file is a RAW format
- */
-export declare function isRawFile(filename: string): boolean;
-/**
- * Extract metadata from RAW file
- */
-export declare function extractMetadata(buffer: ArrayBuffer): RawMetadata;
-/**
- * Extract embedded JPEG preview from RAW file
- */
-export declare function extractPreview(buffer: ArrayBuffer): Promise<ImageData | null>;
-/**
- * Load and process RAW file
- */
-export declare function loadRawFile(buffer: ArrayBuffer, options?: Partial<RawProcessingOptions>): Promise<RawLoadResult>;
-/**
- * Quick preview load (just extract embedded preview)
- */
-export declare function loadRawPreview(buffer: ArrayBuffer): Promise<ImageData | null>;
-export default loadRawFile;

package/dist/types/pixel/PaletteExtractorPanel.d.ts

@@ -1,17 +0,0 @@
-/**
- * PaletteExtractorPanel — UI for extracting palettes from images
- */
-import React from 'react';
-export interface PaletteExtractorPanelProps {
-    /** Current image data to extract from */
-    imageData?: ImageData | null;
-    /** Called when palette is extracted */
-    onExtract?: (colors: string[]) => void;
-    /** Called when palette is applied */
-    onApply?: (colors: string[]) => void;
-    /** Current palette for comparison */
-    currentPalette?: string[];
-    className?: string;
-}
-export declare function PaletteExtractorPanel({ imageData, onExtract, onApply, currentPalette: _currentPalette, className, }: PaletteExtractorPanelProps): React.JSX.Element;
-export default PaletteExtractorPanel;

package/dist/types/pixel/TileMapPanel.d.ts

@@ -1,15 +0,0 @@
-/**
- * TileMapPanel — UI panel for tile map mode settings
- */
-import React from 'react';
-import type { TileMapSettings } from './tileMapMode';
-export interface TileMapPanelProps {
-    settings: TileMapSettings;
-    onSettingsChange: (settings: Partial<TileMapSettings>) => void;
-    seamScore?: number;
-    onMakeSeamless?: () => void;
-    onAnalyzeSeams?: () => void;
-    className?: string;
-}
-export declare function TileMapPanel({ settings, onSettingsChange, seamScore, onMakeSeamless, onAnalyzeSeams, className, }: TileMapPanelProps): React.JSX.Element;
-export default TileMapPanel;

package/dist/types/pixel/paletteExtractor.d.ts

@@ -1,73 +0,0 @@
-/**
- * paletteExtractor — Extract color palettes from images
- *
- * Features:
- * - K-means clustering for dominant colors
- * - Median cut algorithm
- * - Octree quantization
- * - Color sorting options
- * - Palette size control
- * - Common palette format imports (GPL, PAL, ASE, ACO)
- */
-export interface RGB {
-    r: number;
-    g: number;
-    b: number;
-}
-export interface PaletteColor extends RGB {
-    hex: string;
-    count: number;
-    percentage: number;
-}
-export type ExtractionAlgorithm = 'kmeans' | 'median-cut' | 'octree' | 'frequency';
-export type SortOrder = 'frequency' | 'hue' | 'saturation' | 'lightness' | 'brightness' | 'none';
-export interface ExtractionOptions {
-    /** Number of colors to extract */
-    colorCount: number;
-    /** Algorithm to use */
-    algorithm: ExtractionAlgorithm;
-    /** Sort order for results */
-    sortOrder: SortOrder;
-    /** Minimum color difference (0-255) to include similar colors */
-    minDifference: number;
-    /** Sample rate (1 = every pixel, 2 = every 2nd, etc.) */
-    sampleRate: number;
-    /** Ignore transparent pixels */
-    ignoreTransparent: boolean;
-}
-export declare const DEFAULT_EXTRACTION_OPTIONS: ExtractionOptions;
-export declare function rgbToHex(r: number, g: number, b: number): string;
-export declare function hexToRgb(hex: string): RGB;
-export declare function colorDistance(c1: RGB, c2: RGB): number;
-export declare function rgbToHsl(r: number, g: number, b: number): {
-    h: number;
-    s: number;
-    l: number;
-};
-export declare function getBrightness(r: number, g: number, b: number): number;
-export declare function extractPalette(imageData: ImageData, options?: Partial<ExtractionOptions>): PaletteColor[];
-/**
- * Extract palette from image/canvas element
- */
-export declare function extractPaletteFromImage(source: HTMLImageElement | HTMLCanvasElement, options?: Partial<ExtractionOptions>): PaletteColor[];
-/**
- * Parse GIMP Palette (.gpl) format
- */
-export declare function parseGplPalette(content: string): string[];
-/**
- * Parse Paint.NET/JASC Palette (.pal) format
- */
-export declare function parsePalPalette(content: string): string[];
-/**
- * Parse hex color list (one per line)
- */
-export declare function parseHexPalette(content: string): string[];
-/**
- * Export palette to GPL format
- */
-export declare function exportToGpl(colors: string[], name?: string): string;
-/**
- * Export palette to PAL format
- */
-export declare function exportToPal(colors: string[]): string;
-export default extractPalette;

package/dist/types/pixel/pixelAnimationPresets.d.ts

@@ -1,79 +0,0 @@
-/**
- * pixelAnimationPresets.ts — Frame interpolation, transitions, and animation helpers.
- *
- * Features:
- *  - Frame-to-frame interpolation (tween ImageData)
- *  - Transition effects between frames (dissolve, slide, wipe, morph, iris)
- *  - Default animation sequences (idle, walk, run, attack cycles)
- *  - Onion skin rendering
- *  - Frame timing utilities
- */
-import { type RGBA } from './pixelEditorUtils';
-export interface FrameTransition {
-    id: string;
-    name: string;
-    category: TransitionCategory;
-    /** Generate intermediate frames between from→to */
-    generate: (from: ImageData, to: ImageData, steps: number) => ImageData[];
-}
-export type TransitionCategory = 'blend' | 'slide' | 'wipe' | 'special' | 'pixelate';
-export interface AnimationSequence {
-    id: string;
-    name: string;
-    /** Description of the motion */
-    description: string;
-    /** Number of frames recommended */
-    frameCount: number;
-    /** Recommended FPS */
-    fps: number;
-    loop: boolean;
-    /** Per-frame transform hints (translate/rotate sprite between frames) */
-    frameHints: FrameHint[];
-}
-export interface FrameHint {
-    /** Label for this frame's purpose */
-    label: string;
-    /** Suggested X offset from base position */
-    offsetX: number;
-    /** Suggested Y offset from base position */
-    offsetY: number;
-    /** Suggested rotation (degrees) */
-    rotation: number;
-    /** Suggested scale factor */
-    scale: number;
-    /** Frame duration multiplier (1 = normal) */
-    durationMultiplier: number;
-}
-export interface OnionSkinConfig {
-    enabled: boolean;
-    /** How many frames before to show */
-    framesBefore: number;
-    /** How many frames after to show */
-    framesAfter: number;
-    /** Opacity for previous frames (0-1) */
-    opacityBefore: number;
-    /** Opacity for next frames (0-1) */
-    opacityAfter: number;
-    /** Color tint for previous frames */
-    tintBefore: RGBA;
-    /** Color tint for next frames */
-    tintAfter: RGBA;
-    /** Opacity falloff per frame */
-    falloff: number;
-}
-/** Pixel-level crossfade between two frames */
-export declare function interpolateFrames(from: ImageData, to: ImageData, t: number): ImageData;
-/** Generate N intermediate frames between from and to */
-export declare function generateTweenFrames(from: ImageData, to: ImageData, count: number): ImageData[];
-export declare const FRAME_TRANSITIONS: FrameTransition[];
-export declare function getTransitionsByCategory(category: TransitionCategory): FrameTransition[];
-export declare function getTransitionById(id: string): FrameTransition | undefined;
-export declare const ANIMATION_SEQUENCES: AnimationSequence[];
-export declare function getSequenceById(id: string): AnimationSequence | undefined;
-export declare const DEFAULT_ONION_SKIN: OnionSkinConfig;
-/**
- * Render onion skin overlays. Returns an ImageData with the ghosted frames composited.
- */
-export declare function renderOnionSkin(frames: ImageData[], currentFrame: number, config: OnionSkinConfig): ImageData;
-export declare function computeFrameDurations(fps: number, frameCount: number, hints?: FrameHint[]): number[];
-export declare function totalAnimationDuration(fps: number, frameCount: number, hints?: FrameHint[]): number;