@yogiswara/honcho-editor-ui 2.8.8 → 2.8.10

package/dist/index.d.mts

@@ -0,0 +1,1474 @@
+import { SelectChangeEvent } from '@mui/material';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React$1, { ReactElement } from 'react';
+
+interface Log {
+    created_at: string;
+    updated_at: string;
+}
+interface ColorAdjustment {
+    temperature: number;
+    tint: number;
+    saturation: number;
+    vibrance: number;
+    exposure: number;
+    contrast: number;
+    highlights: number;
+    shadows: number;
+    whites: number;
+    blacks: number;
+    clarity: number;
+    sharpness: number;
+}
+interface TransformationAdjustment {
+    angle_score?: number;
+    direction?: "cw" | "ccw";
+    scale_score?: number;
+    keep_dimension?: boolean;
+    flip_mode?: "horizontal" | "vertical" | "mix";
+    aspect_ratio?: string;
+    width?: number;
+    height?: number;
+}
+interface Watermark {
+    path: string;
+    max_pct: [number, number];
+    anchor: [string, number | null, number[] | null];
+    rotate_deg: [number, "cw" | "ccw"];
+}
+interface EditorConfig {
+    color_adjustment: ColorAdjustment;
+    transformation_adjustment?: TransformationAdjustment[];
+    watermarks?: Watermark[];
+}
+interface Content {
+    key: string;
+    path: string;
+    size: number;
+    width: number;
+    height: number;
+}
+interface Content {
+    key: string;
+    path: string;
+    size: number;
+    width: number;
+    height: number;
+}
+interface Gallery {
+    id: string;
+    uid: string;
+    event_id: string;
+    download: Content;
+    download_edited: Content;
+    raw?: Content;
+    raw_edited?: Content;
+    raw_preview?: Content;
+    raw_thumbnail?: Content;
+    original?: Content;
+    original_edited?: Content;
+    large?: Content;
+    large_edited?: Content;
+    medium?: Content;
+    medium_edited?: Content;
+    small?: Content;
+    small_edited?: Content;
+    mini?: Content;
+    mini_edited?: Content;
+    create_from?: string[];
+    thumbnail: Content;
+    thumbnail_edited: Content;
+    is_original: boolean;
+    available: boolean;
+    show_gallery: boolean;
+    editor_config?: EditorConfig;
+    log: Log;
+}
+interface ResponseGalleryPaging {
+    gallery: Gallery[];
+    limit: number;
+    current_page: number;
+    prev_page: number;
+    next_page: number;
+    sum_of_image?: number;
+}
+interface EditorHistoryEntry {
+    id: string;
+    gallery_id: string;
+    event_id: string;
+    task_id: string;
+    editor_config: EditorConfig;
+    log: Log;
+}
+interface CreateEditorTaskRequest {
+    gallery_id: string;
+    task_id: string;
+    color_adjustment: ColorAdjustment;
+    replace_from?: string;
+}
+interface GetHistoryResponse {
+    current_task_id: string;
+    history: EditorHistoryEntry[];
+}
+interface GetGalleryUpdateTimestampResponse {
+    gallery: string[];
+}
+interface AdjustmentState {
+    tempScore: number;
+    tintScore: number;
+    vibranceScore: number;
+    saturationScore: number;
+    exposureScore: number;
+    highlightsScore: number;
+    shadowsScore: number;
+    whitesScore: number;
+    blacksScore: number;
+    contrastScore: number;
+    clarityScore: number;
+    sharpnessScore: number;
+}
+interface Preset$4 {
+    id: string;
+    name: string;
+    is_default: boolean;
+    temperature: number;
+    tint: number;
+    saturation: number;
+    vibrance: number;
+    exposure: number;
+    contrast: number;
+    highlights: number;
+    shadows: number;
+    whites: number;
+    blacks: number;
+    clarity: number;
+    sharpness: number;
+}
+interface Controller {
+    onGetImage(firebaseUid: string, imageID: string): Promise<Gallery>;
+    getImageList(firebaseUid: string, eventId: string, page: number): Promise<ResponseGalleryPaging>;
+    syncConfig(firebaseUid: string): Promise<void>;
+    handleBack(firebaseUid: string, imageID: string): void;
+    getPresets(firebaseUid: string): Promise<Preset$4[]>;
+    createPreset(firebaseUid: string, name: string, settings: AdjustmentState): Promise<void>;
+    deletePreset(firebaseUid: string, presetId: string): Promise<void>;
+    updatePreset(firebaseUid: string, data: Preset$4): Promise<void>;
+    createEditorConfig(firebaseUid: string, payload: CreateEditorTaskRequest): Promise<void>;
+    getEditorHistory(firebaseUid: string, imageID: string): Promise<GetHistoryResponse>;
+    getGalleryUpdateTimestamp(firebaseUid: string, eventID: string, timestamp: number): Promise<GetGalleryUpdateTimestampResponse>;
+    setHistoryIndex(firebaseUid: string, imageID: string, taskID: string): Promise<void>;
+}
+interface ImageItem {
+    id: string;
+    url: string;
+    file: File;
+}
+
+/**
+ *     temperature?: number;   // -100 to 100
+    tint?: number;          // -100 to 100
+    saturation?: number;    // -100 to 100
+    vibrance?: number;      // -100 to 100
+    exposure?: number;      // -100 to 100
+    contrast?: number;      // -100 to 100
+    highlights?: number;    // -100 to 100
+    shadows?: number;       // -100 to 100
+    whites?: number;        // -100 to 100
+    blacks?: number;        // -100 to 100
+    clarity?: number;       // -100 to 100
+    sharpness?: number;     // -100 to 100 Editor - TypeScript Definitions
+ * 
+ * Type definitions for the Honcho Photo Editor JavaScript library.
+ */
+
+interface AdjustmentValues {
+    temperature?: number;    // -100 to 100
+    tint?: number;          // -100 to 100
+    saturation?: number;     // -1 to 1
+    vibrance?: number;      // -1 to 1
+    exposure?: number;       // -3 to 3
+    contrast?: number;       // -1 to 1
+    highlights?: number;     // -1 to 1
+    shadows?: number;        // -1 to 1
+    whites?: number;        // -1 to 1
+    blacks?: number;        // -1 to 1
+    clarity?: number;       // -1 to 1
+    sharpness?: number;     // -1 to 1
+}
+
+interface ImageSize {
+    width: number;
+    height: number;
+}
+
+interface AdjustmentRange {
+    min: number;
+    max: number;
+    default: number;
+    step: number;
+}
+
+interface AdjustmentRanges {
+    temperature: AdjustmentRange;
+    tint: AdjustmentRange;
+    saturation: AdjustmentRange;
+    vibrance: AdjustmentRange;
+    exposure: AdjustmentRange;
+    contrast: AdjustmentRange;
+    highlights: AdjustmentRange;
+    shadows: AdjustmentRange;
+    whites: AdjustmentRange;
+    blacks: AdjustmentRange;
+    clarity: AdjustmentRange;
+    sharpness: AdjustmentRange;
+}
+
+declare class HonchoEditor {
+    constructor();
+    
+    // Initialization - must be called before any other methods
+    initialize(verbose?: boolean): Promise<boolean>;
+    
+    // Image Loading
+    loadImageFromFile(file: File): Promise<ImageSize>;
+    loadImageFromUrl(url: string): Promise<ImageSize>;
+    loadImageFromImageElement(img: HTMLImageElement): ImageSize;
+    loadImageFromImageData(imageData: ImageData): ImageSize;
+    
+    // Adjustments (all auto-trigger re-render)
+    setTemperature(value: number): void;
+    setTint(value: number): void;
+    setSaturation(value: number): void;
+    setVibrance(value: number): void;
+    setExposure(value: number): void;
+    setContrast(value: number): void;
+    setHighlights(value: number): void;
+    setShadows(value: number): void;
+    setWhites(value: number): void;
+    setBlacks(value: number): void;
+    setClarity(value: number): void;
+    setSharpness(value: number): void;
+    
+    // Batch adjustments
+    setAdjustments(adjustments: AdjustmentValues): void;
+    
+        // Reset all adjustments to default values
+    resetAdjustments(): void;
+    
+    // Manual processing trigger - call this after setting adjustments
+    processImage(): void;
+    
+    // Frame functionality
+    setFrame(frameData: Uint8Array, frameWidth: number, frameHeight: number, frameChannels: number): boolean;
+    setFrameFromImageData(frameImageData: ImageData): boolean;
+    setFrameFromCanvas(frameCanvas: HTMLCanvasElement): boolean;
+    clearFrame(): void;
+    hasFrame(): boolean;
+    
+    // Convenience methods
+    processImageOneShot(
+        imageSource: File | ImageData | HTMLImageElement,
+        adjustments?: Partial<AdjustmentValues>,
+        frameSource?: File | ImageData | HTMLImageElement | null
+    ): Promise<ImageData>;
+    
+    // Rendering
+    renderToCanvas(canvas: HTMLCanvasElement): void;  // GPU path <1ms
+    getProcessedImageData(): ImageData;               // CPU path 50-100ms
+    
+    // Utilities
+    getImageSize(): ImageSize;
+    getInitialized(): boolean;
+    getRawModule(): any;
+    
+    // Cleanup
+    cleanup(): void;
+}
+
+interface UseHonchoEditorSingleOptions {
+    controller: Controller;
+    initImageId: string;
+    firebaseUid: string;
+}
+interface UseHonchoEditorSingleState {
+    currentImageData: Gallery | null;
+    isGalleryLoading: boolean;
+    galleryError: string | null;
+    currentAdjustments: AdjustmentState;
+    isBatchMode: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+    isNextAvailable: boolean;
+    isPrevAvailable: boolean;
+    presets: Preset$4[];
+    activePreset: Preset$4 | null;
+    presetsLoading: boolean;
+    presetsError: string | null;
+}
+interface UseHonchoEditorSingleActions {
+    navigateNext: () => void;
+    navigatePrev: () => void;
+    updateAdjustment: (field: keyof AdjustmentState, value: number) => void;
+    setBatchMode: (enabled: boolean) => void;
+    startBatchMode: () => void;
+    endBatchMode: () => void;
+    undo: () => void;
+    redo: () => void;
+    reset: () => void;
+    loadPresets: () => Promise<void>;
+    applyPreset: (preset: Preset$4) => void;
+    createPreset: (name: string, adjustments: AdjustmentState) => Promise<Preset$4 | null>;
+    renamePreset: (presetId: string, newName: string) => Promise<boolean>;
+    deletePreset: (presetId: string) => Promise<void>;
+    getEditorAdjustments: () => AdjustmentValues;
+}
+declare function useHonchoEditorSingle({ controller, initImageId, firebaseUid }: UseHonchoEditorSingleOptions): {
+    state: UseHonchoEditorSingleState;
+    actions: UseHonchoEditorSingleActions;
+};
+
+/**
+ * Configuration for image with adjustment state
+ */
+interface ImageAdjustmentConfig {
+    imageId: string;
+    /** Adjustment state for this image. If not provided, uses default (all zeros) */
+    adjustment?: AdjustmentState;
+}
+/**
+ * Batch adjustment state - maps image IDs to their adjustment states
+ */
+interface BatchAdjustmentState {
+    /** Currently selected images that are being actively adjusted */
+    currentSelection: {
+        [imageId: string]: AdjustmentState;
+    };
+    /** All images that have been selected/adjusted before (persistent state) */
+    allImages: {
+        [imageId: string]: AdjustmentState;
+    };
+    /** Track initial/baseline state for each image */
+    initialStates: {
+        [imageId: string]: AdjustmentState;
+    };
+}
+/**
+ * Configuration options for the batch adjustment history hook
+ */
+interface BatchHistoryOptions {
+    /** Maximum number of history entries to keep. Use 'unlimited' for no limit */
+    maxSize?: number | 'unlimited';
+    /** Enable development warnings for performance issues */
+    devWarnings?: boolean;
+    /** Default adjustment state for new images */
+    defaultAdjustmentState?: Partial<AdjustmentState>;
+    /** Controller for backend operations */
+    controller?: Controller;
+    /** Firebase UID for backend operations */
+    firebaseUid?: string;
+    /** Event ID for backend operations */
+    eventId?: string;
+}
+/**
+ * Information about the current batch history state
+ */
+interface BatchHistoryInfo {
+    /** Whether undo operation is available for selected images */
+    canUndo: boolean;
+    /** Whether redo operation is available for selected images */
+    canRedo: boolean;
+    /** Current position in history (0-based index) */
+    currentIndex: number;
+    /** Total number of states in history */
+    totalStates: number;
+    /** Number of currently selected images */
+    selectedCount: number;
+    /** Total number of images being managed */
+    totalImages: number;
+    /** Current size of history in memory */
+    historySize: number;
+}
+/**
+ * Actions available for batch history management
+ */
+interface BatchHistoryActions {
+    /** Apply adjustment deltas to selected images */
+    adjustSelected: (delta: Partial<AdjustmentState>) => void;
+    /** Apply preset values directly to selected images (preserves history) */
+    adjustSelectedWithPreset: (presetAdjustments: AdjustmentState) => void;
+    /** Undo last changes to selected images */
+    undo: () => void;
+    /** Redo next changes to selected images */
+    redo: () => void;
+    /** Reset selected images to default state */
+    reset: (imageIds?: string[]) => void;
+    /** Set selection with optional initial adjustments per image */
+    setSelection: (configs: ImageAdjustmentConfig[]) => void;
+    /** Sync/replace adjustment for images (clears their history) */
+    syncAdjustment: (configs: ImageAdjustmentConfig[]) => void;
+    /** Check for gallery updates and sync history for updated images */
+    syncGalleryUpdates: () => Promise<void>;
+    /** Add or remove image from selection */
+    toggleSelection: (imageId: string) => void;
+    /** Select all images */
+    selectAll: () => void;
+    /** Clear selection */
+    clearSelection: () => void;
+    /** Jump to specific index in history */
+    jumpToIndex: (index: number) => void;
+    /** Clear all history and start fresh */
+    clearHistory: () => void;
+    /** Get copy of current batch state */
+    getCurrentBatch: () => BatchAdjustmentState;
+    /** Sync entire batch state */
+    syncBatch: (newBatch: BatchAdjustmentState, targetIndex?: number) => void;
+}
+/**
+ * Configuration actions for runtime adjustment
+ */
+interface BatchHistoryConfig {
+    /** Set maximum history size */
+    setMaxSize: (size: number | 'unlimited') => void;
+    /** Get current memory usage estimate */
+    getMemoryUsage: () => number;
+}
+/**
+ * Return type for the useAdjustmentHistoryBatch hook
+ */
+interface UseAdjustmentHistoryBatchReturn {
+    /** Current batch adjustment state */
+    currentBatch: BatchAdjustmentState;
+    /** Currently selected image IDs */
+    selectedIds: string[];
+    /** All image IDs being managed */
+    allImageIds: string[];
+    /** Information about history state */
+    historyInfo: BatchHistoryInfo;
+    /** Available history actions */
+    actions: BatchHistoryActions;
+    /** Configuration options */
+    config: BatchHistoryConfig;
+}
+/**
+ * Advanced hook for managing batch AdjustmentState history with selective undo/redo functionality.
+ *
+ * **Pure State Management Design:**
+ * - Starts empty, no image loading functionality
+ * - Focus on state management and history tracking only
+ * - Selection-based operations with persistent state
+ * - Manual selection via `actions.setSelection()`
+ *
+ * **Key Features:**
+ * - **Current Selection**: Images actively being adjusted
+ * - **All Images**: Persistent state for every image touched
+ * - **Selective Operations**: Undo/redo only affects selected images
+ * - **Automatic State Persistence**: Images remain in allImages even when deselected
+ *
+ * **Typical Usage Flow:**
+ * ```typescript
+ * const { actions, currentBatch, selectedIds } = useAdjustmentHistoryBatch();
+ *
+ * // Select images (new images get default state automatically)
+ * actions.setSelection(['img1', 'img2', 'img3']);
+ *
+ * // Apply adjustments to selected images
+ * actions.adjustSelected({ exposureScore: 10 });
+ *
+ * // Change selection (img1, img2 state persists in allImages)
+ * actions.setSelection(['img3']);
+ *
+ * // Adjust only img3
+ * actions.adjustSelected({ contrastScore: 5 });
+ *
+ * // Undo affects only currently selected (img3)
+ * actions.undo();
+ * ```
+ *
+ * **State Structure:**
+ * - `currentBatch.currentSelection`: Currently selected images and their states
+ * - `currentBatch.allImages`: All images that have been selected/adjusted (persistent)
+ * - `selectedIds`: Array of currently selected image IDs
+ *
+ * @param options - Configuration options for history behavior
+ * @returns Object with current batch, selection, history info, actions, and config
+ */
+declare function useAdjustmentHistoryBatch(options?: BatchHistoryOptions): UseAdjustmentHistoryBatchReturn;
+
+/**
+ * Configuration options for the preset hook
+ */
+interface PresetOptions {
+    /** Enable development warnings for debugging */
+    devWarnings?: boolean;
+    /** Auto-load presets on hook initialization */
+    autoLoad?: boolean;
+}
+/**
+ * Information about the current preset state
+ */
+interface PresetInfo {
+    /** Whether presets are currently being loaded */
+    isLoading: boolean;
+    /** Error message if any operation failed */
+    error: string | null;
+    /** Number of presets currently managed */
+    count: number;
+    /** Whether the hook has been initialized */
+    isInitialized: boolean;
+}
+/**
+ * Actions available for preset management
+ */
+interface PresetActions {
+    /** Create a new preset */
+    create: (name: string, settings: AdjustmentState) => Promise<Preset$4 | null>;
+    /** Rename an existing preset */
+    rename: (presetId: string, newName: string) => Promise<boolean>;
+    /** Delete a preset */
+    delete: (presetId: string) => Promise<boolean>;
+    /** Load/refresh presets from backend */
+    load: () => Promise<void>;
+    /** Find preset that matches the given adjustment state */
+    findByAdjustments: (adjustments: AdjustmentState) => Preset$4 | null;
+}
+/**
+ * Return type for the usePreset hook
+ */
+interface UsePresetReturn {
+    /** Current list of presets */
+    presets: Preset$4[];
+    /** Information about preset state */
+    info: PresetInfo;
+    /** Available preset actions */
+    actions: PresetActions;
+}
+/**
+ * Hook for managing presets with backend communication through Controller.
+ *
+ * **Key Features:**
+ * - **Backend Communication**: All operations go through the provided Controller
+ * - **Local State Management**: Maintains local preset list for UI performance
+ * - **CRUD Operations**: Create, rename, delete, and list presets
+ * - **Error Handling**: Provides error states for failed operations
+ * - **Auto-loading**: Optional automatic preset loading on initialization
+ *
+ * **Typical Usage:**
+ * ```typescript
+ * const { presets, actions, info } = usePreset(controller, firebaseUid, { autoLoad: true });
+ *
+ * // Create preset
+ * const newPreset = await actions.create('My Preset', adjustmentState);
+ *
+ * // Rename preset
+ * const success = await actions.rename(presetId, 'New Name');
+ *
+ * // Delete preset
+ * const deleted = await actions.delete(presetId);
+ *
+ * // Manual reload
+ * await actions.load();
+ * ```
+ *
+ * @param controller - Backend controller for API communication
+ * @param firebaseUid - User identifier for backend operations
+ * @param options - Configuration options
+ * @returns Object with presets, info, and actions
+ */
+declare function usePreset(controller: Controller | null, firebaseUid: string, options?: PresetOptions): UsePresetReturn;
+
+interface PhotoData {
+    key: string;
+    src: string;
+    original: string;
+    width: number;
+    height: number;
+    alt: string;
+    isSelected: boolean;
+    adjustments?: Partial<AdjustmentValues>;
+}
+/**
+ * Hook for bulk photo editing with multi-image backend synchronization.
+ *
+ * **Multi-Image Backend Sync:**
+ * - Each selected image maintains its own history and backend state
+ * - History operations (undo/redo) trigger separate controller.setHistoryIndex() calls for each selected image
+ * - Preset application triggers separate controller.createEditorConfig() calls for each selected image
+ * - Adjustment changes trigger separate controller.createEditorConfig() calls for each selected image
+ *
+ * **Key Features:**
+ * - Individual history tracking per image with backend persistence
+ * - Bulk operations that respect per-image differences
+ * - Automatic backend synchronization for all state changes
+ * - Comprehensive logging of multi-image operations
+ */
+declare function useHonchoEditorBulk(controller: Controller, eventID: string, firebaseUid: string): {
+    imageData: PhotoData[];
+    isLoading: boolean;
+    error: string | null;
+    selectedIds: string[];
+    hasMore: boolean;
+    handleBackCallbackBulk: () => void;
+    presets: Preset$4[];
+    selectedBulkPreset: string;
+    activePreset: Preset$4 | null;
+    handleSelectBulkPreset: (event: SelectChangeEvent<string>) => void;
+    presetActions: PresetActions;
+    handleToggleImageSelection: (imageId: string) => void;
+    handleLoadMore: () => Promise<void>;
+    handleRefresh: () => Promise<void>;
+    handleBulkTempDecreaseMax: () => void;
+    handleBulkTempDecrease: () => void;
+    handleBulkTempIncrease: () => void;
+    handleBulkTempIncreaseMax: () => void;
+    handleBulkTintDecreaseMax: () => void;
+    handleBulkTintDecrease: () => void;
+    handleBulkTintIncrease: () => void;
+    handleBulkTintIncreaseMax: () => void;
+    handleBulkVibranceDecreaseMax: () => void;
+    handleBulkVibranceDecrease: () => void;
+    handleBulkVibranceIncrease: () => void;
+    handleBulkVibranceIncreaseMax: () => void;
+    handleBulkSaturationDecreaseMax: () => void;
+    handleBulkSaturationDecrease: () => void;
+    handleBulkSaturationIncrease: () => void;
+    handleBulkSaturationIncreaseMax: () => void;
+    handleBulkExposureDecreaseMax: () => void;
+    handleBulkExposureDecrease: () => void;
+    handleBulkExposureIncrease: () => void;
+    handleBulkExposureIncreaseMax: () => void;
+    handleBulkContrastDecreaseMax: () => void;
+    handleBulkContrastDecrease: () => void;
+    handleBulkContrastIncrease: () => void;
+    handleBulkContrastIncreaseMax: () => void;
+    handleBulkHighlightsDecreaseMax: () => void;
+    handleBulkHighlightsDecrease: () => void;
+    handleBulkHighlightsIncrease: () => void;
+    handleBulkHighlightsIncreaseMax: () => void;
+    handleBulkShadowsDecreaseMax: () => void;
+    handleBulkShadowsDecrease: () => void;
+    handleBulkShadowsIncrease: () => void;
+    handleBulkShadowsIncreaseMax: () => void;
+    handleBulkWhitesDecreaseMax: () => void;
+    handleBulkWhitesDecrease: () => void;
+    handleBulkWhitesIncrease: () => void;
+    handleBulkWhitesIncreaseMax: () => void;
+    handleBulkBlacksDecreaseMax: () => void;
+    handleBulkBlacksDecrease: () => void;
+    handleBulkBlacksIncrease: () => void;
+    handleBulkBlacksIncreaseMax: () => void;
+    handleBulkClarityDecreaseMax: () => void;
+    handleBulkClarityDecrease: () => void;
+    handleBulkClarityIncrease: () => void;
+    handleBulkClarityIncreaseMax: () => void;
+    handleBulkSharpnessDecreaseMax: () => void;
+    handleBulkSharpnessDecrease: () => void;
+    handleBulkSharpnessIncrease: () => void;
+    handleBulkSharpnessIncreaseMax: () => void;
+    handleUndo: () => void;
+    handleRedo: () => void;
+    handleReset: (imageIds?: string[]) => void;
+    historyInfo: BatchHistoryInfo;
+};
+
+interface Props$i {
+    anchorEl?: null | HTMLElement;
+    valueSelect?: string;
+    isPasteEnabled?: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+    onBack?: () => void;
+    onUndo?: () => void;
+    onRedo?: () => void;
+    onRevert?: () => void;
+    onCopyEdit?: () => void;
+    onPasteEdit?: () => void;
+    onMenuClick?: (event: React$1.MouseEvent<HTMLElement>) => void;
+    onMenuClose?: () => void;
+    onSelectButton?: () => void;
+}
+declare function HHeaderEditor(props: Props$i): react_jsx_runtime.JSX.Element;
+
+interface Props$h {
+    anchorElZoom: null | HTMLElement;
+    onScale: (event: React$1.MouseEvent<HTMLElement>) => void;
+    onZoomMenuClose: () => void;
+    zoomLevelText: string;
+    onZoomAction: (zoomLevel: string) => void;
+    onShowOriginal?: () => void;
+    onShowEdited?: () => void;
+}
+declare function HFooter(props: Props$h): react_jsx_runtime.JSX.Element;
+
+interface Props$g {
+    tempScore: number;
+    tintScore: number;
+    vibranceScore: number;
+    saturationScore: number;
+    exposureScore: number;
+    HighlightsScore: number;
+    shadowsScore: number;
+    whitesScore: number;
+    blacksScore: number;
+    contrastScore: number;
+    clarityScore: number;
+    sharpnessScore: number;
+    expandedPanels: string[];
+    setTempScore: (field: keyof AdjustmentState, value: number) => void;
+    setTintScore: (field: keyof AdjustmentState, value: number) => void;
+    setExposureScore: (field: keyof AdjustmentState, value: number) => void;
+    setVibranceScore: (field: keyof AdjustmentState, value: number) => void;
+    setSaturationScore: (field: keyof AdjustmentState, value: number) => void;
+    setHighlightsScore: (field: keyof AdjustmentState, value: number) => void;
+    setShadowsScore: (field: keyof AdjustmentState, value: number) => void;
+    setWhitesScore: (field: keyof AdjustmentState, value: number) => void;
+    setBlacksScore: (field: keyof AdjustmentState, value: number) => void;
+    setContrastScore: (field: keyof AdjustmentState, value: number) => void;
+    setClarityScore: (field: keyof AdjustmentState, value: number) => void;
+    setSharpnessScore: (field: keyof AdjustmentState, value: number) => void;
+    onPanelChange: (panel: string) => (event: React$1.SyntheticEvent, isExpanded: boolean) => void;
+    isBatchMode: boolean;
+    onDragStart: () => void;
+    onDragEnd: () => void;
+}
+declare function HAccordionColorAdjustment(props: Props$g): react_jsx_runtime.JSX.Element;
+
+type Preset$3 = {
+    id: string;
+    name: string;
+};
+interface Props$f {
+    presets: Preset$3[];
+    expandedPanels: string[];
+    selectedPreset: string | null;
+    presetMenuAnchorEl: null | HTMLElement;
+    activePresetMenuId: string | null;
+    onChange: (panel: string) => (event: React$1.SyntheticEvent, isExpanded: boolean) => void;
+    onOpenPresetModal: () => void;
+    onOpenWatermarkView: () => void;
+    onSelectPreset: (id: string) => void;
+    onPresetMenuClick: (event: React$1.MouseEvent<HTMLElement>, presetId: string) => void;
+    onPresetMenuClose: () => void;
+    onRemovePreset: () => void;
+    onRenamePreset: () => void;
+    onDeletePreset: () => void;
+}
+declare function HAccordionPreset(props: Props$f): react_jsx_runtime.JSX.Element;
+
+interface Props$e {
+    open: boolean;
+    title: React$1.ReactNode;
+    description?: React$1.ReactNode | ReactElement;
+    onClose?: () => void;
+    action?: React$1.ReactNode;
+    actionAdjust?: React$1.ReactNode;
+}
+declare function HBaseDialog(props: Props$e): react_jsx_runtime.JSX.Element;
+declare function HDialogForPreset(props: Props$e): react_jsx_runtime.JSX.Element;
+
+type CheckState = {
+    [key: string]: boolean;
+};
+interface Props$d {
+    colorChecks: CheckState;
+    lightChecks: CheckState;
+    detailsChecks: CheckState;
+    expanded: {
+        color: boolean;
+        light: boolean;
+        details: boolean;
+    };
+    onCopyEdit: () => void;
+    onParentChange: (event: React$1.ChangeEvent<HTMLInputElement>, setter: React$1.Dispatch<React$1.SetStateAction<any>>) => void;
+    onChildChange: (event: React$1.ChangeEvent<HTMLInputElement>, setter: React$1.Dispatch<React$1.SetStateAction<any>>) => void;
+    onToggleExpand: (section: 'color' | 'light' | 'details') => void;
+    setColorChecks: React$1.Dispatch<React$1.SetStateAction<any>>;
+    setLightChecks: React$1.Dispatch<React$1.SetStateAction<any>>;
+    setDetailsChecks: React$1.Dispatch<React$1.SetStateAction<any>>;
+}
+declare function HDialogCopy(props: Props$d): react_jsx_runtime.JSX.Element;
+interface PropsPreset {
+    colorChecks: CheckState;
+    lightChecks: CheckState;
+    detailsChecks: CheckState;
+    expanded: {
+        color: boolean;
+        light: boolean;
+        details: boolean;
+    };
+    onParentChange: (event: React$1.ChangeEvent<HTMLInputElement>, setter: React$1.Dispatch<React$1.SetStateAction<any>>) => void;
+    onChildChange: (event: React$1.ChangeEvent<HTMLInputElement>, setter: React$1.Dispatch<React$1.SetStateAction<any>>) => void;
+    onToggleExpand: (section: 'color' | 'light' | 'details') => void;
+    setColorChecks: React$1.Dispatch<React$1.SetStateAction<any>>;
+    setLightChecks: React$1.Dispatch<React$1.SetStateAction<any>>;
+    setDetailsChecks: React$1.Dispatch<React$1.SetStateAction<any>>;
+    descriptionOnCopy?: string;
+}
+declare function HDialogPreset(propsPreset: PropsPreset): react_jsx_runtime.JSX.Element;
+
+type Preset$2 = {
+    id: string;
+    name: string;
+};
+interface Props$c {
+    presets: Preset$2[];
+    activePanel: string;
+    activeSubPanel: string;
+    setActivePanel: (tab: string) => void;
+    setActiveSubPanel: (subTab: string) => void;
+    activeTab: string;
+    innerRef?: React$1.Ref<HTMLDivElement>;
+    panelRef: React$1.RefObject<HTMLDivElement>;
+    contentRef: React$1.RefObject<HTMLDivElement | null>;
+    panelHeight: number;
+    handleDragStart: (e: React$1.MouseEvent | React$1.TouchEvent) => void;
+    onContentHeightChange: (height: number) => void;
+    tempScore: number;
+    tintScore: number;
+    vibranceScore: number;
+    saturationScore: number;
+    exposureScore: number;
+    highlightsScore: number;
+    shadowScore: number;
+    whiteScore: number;
+    blackScore: number;
+    contrastScore: number;
+    clarityScore: number;
+    sharpnessScore: number;
+    onTempChange: (field: keyof AdjustmentState, value: number) => void;
+    onTintChange: (field: keyof AdjustmentState, value: number) => void;
+    onVibranceChange: (field: keyof AdjustmentState, value: number) => void;
+    onSaturationChange: (field: keyof AdjustmentState, value: number) => void;
+    onExposureChange: (field: keyof AdjustmentState, value: number) => void;
+    onHighlightsChange: (field: keyof AdjustmentState, value: number) => void;
+    onShadowsChange: (field: keyof AdjustmentState, value: number) => void;
+    onWhitesChange: (field: keyof AdjustmentState, value: number) => void;
+    onBlacksChange: (field: keyof AdjustmentState, value: number) => void;
+    onContrastChange: (field: keyof AdjustmentState, value: number) => void;
+    onClarityChange: (field: keyof AdjustmentState, value: number) => void;
+    onSharpnessChange: (field: keyof AdjustmentState, value: number) => void;
+    isBatchMode: boolean;
+    onDragStart: () => void;
+    onDragEnd: () => void;
+    selectedPreset: string | null;
+    onSelectPreset: (id: string) => void;
+    onOpenPresetModal: () => void;
+    presetOptionModal: (event: React$1.MouseEvent<HTMLElement>, presetId: string) => void;
+}
+declare function HImageEditorMobile(props: Props$c): react_jsx_runtime.JSX.Element;
+
+interface Props$b {
+    activePanel: string;
+    isPanelOpen: boolean;
+    anchorElZoom: null | HTMLElement;
+    children: React$1.ReactNode;
+    footer: React$1.ReactNode;
+    setActivePanel: (accordion: string) => void;
+    onScale: (event: React$1.MouseEvent<HTMLElement>) => void;
+    onBeforeAfter: () => void;
+    onZoomMenuClose: () => void;
+    onZoomAction: (zoomLevel: string) => void;
+}
+declare function HImageEditorDesktop(props: Props$b): react_jsx_runtime.JSX.Element;
+
+interface Props$a {
+    activePanel: string;
+    isPanelOpen: boolean;
+    anchorElZoom: null | HTMLElement;
+    children: React$1.ReactNode;
+    footer: React$1.ReactNode;
+    setActivePanel: (accordion: string) => void;
+    onScale: (event: React$1.MouseEvent<HTMLElement>) => void;
+    onBeforeAfter: () => void;
+    onZoomMenuClose: () => void;
+    onZoomAction: (zoomLevel: string) => void;
+}
+declare function HImageEditorBulkDekstop(props: Props$a): react_jsx_runtime.JSX.Element;
+
+type Preset$1 = {
+    id: string;
+    name: string;
+};
+interface Props$9 {
+    presets: Preset$1[];
+    activePanel: string;
+    activeSubPanel: string;
+    setActivePanel: (tab: string) => void;
+    setActiveSubPanel: (subTab: string) => void;
+    panelRef: React$1.RefObject<HTMLDivElement>;
+    contentRef: React$1.RefObject<HTMLDivElement | null>;
+    panelHeight: number;
+    handleDragStart: (e: React$1.MouseEvent | React$1.TouchEvent) => void;
+    onContentHeightChange: (height: number) => void;
+    onTempDecreaseMax: () => void;
+    onTempDecrease: () => void;
+    onTempIncrease: () => void;
+    onTempIncreaseMax: () => void;
+    onTintDecreaseMax: () => void;
+    onTintDecrease: () => void;
+    onTintIncrease: () => void;
+    onTintIncreaseMax: () => void;
+    onVibranceDecreaseMax: () => void;
+    onVibranceDecrease: () => void;
+    onVibranceIncrease: () => void;
+    onVibranceIncreaseMax: () => void;
+    onSaturationDecreaseMax: () => void;
+    onSaturationDecrease: () => void;
+    onSaturationIncrease: () => void;
+    onSaturationIncreaseMax: () => void;
+    onExposureDecreaseMax: () => void;
+    onExposureDecrease: () => void;
+    onExposureIncrease: () => void;
+    onExposureIncreaseMax: () => void;
+    onContrastDecreaseMax: () => void;
+    onContrastDecrease: () => void;
+    onContrastIncrease: () => void;
+    onContrastIncreaseMax: () => void;
+    onHighlightsDecreaseMax: () => void;
+    onHighlightsDecrease: () => void;
+    onHighlightsIncrease: () => void;
+    onHighlightsIncreaseMax: () => void;
+    onShadowsDecreaseMax: () => void;
+    onShadowsDecrease: () => void;
+    onShadowsIncrease: () => void;
+    onShadowsIncreaseMax: () => void;
+    onWhitesDecreaseMax: () => void;
+    onWhitesDecrease: () => void;
+    onWhitesIncrease: () => void;
+    onWhitesIncreaseMax: () => void;
+    onBlacksDecreaseMax: () => void;
+    onBlacksDecrease: () => void;
+    onBlacksIncrease: () => void;
+    onBlacksIncreaseMax: () => void;
+    onClarityDecreaseMax: () => void;
+    onClarityDecrease: () => void;
+    onClarityIncrease: () => void;
+    onClarityIncreaseMax: () => void;
+    onSharpnessDecreaseMax: () => void;
+    onSharpnessDecrease: () => void;
+    onSharpnessIncrease: () => void;
+    onSharpnessIncreaseMax: () => void;
+    selectedPresetBulk: string;
+    onSelectPresetBulk: (event: SelectChangeEvent<string>) => void;
+    onPresetMenuClickBulk: (event: React$1.MouseEvent<HTMLElement>, presetId: string) => void;
+    onOpenPresetModalBulk: () => void;
+}
+declare function HImageEditorBulkMobile(props: Props$9): react_jsx_runtime.JSX.Element;
+
+interface Props$8 {
+    onTempDecreaseMax: () => void;
+    onTempDecrease: () => void;
+    onTempIncrease: () => void;
+    onTempIncreaseMax: () => void;
+    onTintDecreaseMax: () => void;
+    onTintDecrease: () => void;
+    onTintIncrease: () => void;
+    onTintIncreaseMax: () => void;
+    onVibranceDecreaseMax: () => void;
+    onVibranceDecrease: () => void;
+    onVibranceIncrease: () => void;
+    onVibranceIncreaseMax: () => void;
+    onSaturationDecreaseMax: () => void;
+    onSaturationDecrease: () => void;
+    onSaturationIncrease: () => void;
+    onSaturationIncreaseMax: () => void;
+    onExposureDecreaseMax: () => void;
+    onExposureDecrease: () => void;
+    onExposureIncrease: () => void;
+    onExposureIncreaseMax: () => void;
+    onContrastDecreaseMax: () => void;
+    onContrastDecrease: () => void;
+    onContrastIncrease: () => void;
+    onContrastIncreaseMax: () => void;
+    onHighlightsDecreaseMax: () => void;
+    onHighlightsDecrease: () => void;
+    onHighlightsIncrease: () => void;
+    onHighlightsIncreaseMax: () => void;
+    onShadowsDecreaseMax: () => void;
+    onShadowsDecrease: () => void;
+    onShadowsIncrease: () => void;
+    onShadowsIncreaseMax: () => void;
+    onWhitesDecreaseMax: () => void;
+    onWhitesDecrease: () => void;
+    onWhitesIncrease: () => void;
+    onWhitesIncreaseMax: () => void;
+    onBlacksDecreaseMax: () => void;
+    onBlacksDecrease: () => void;
+    onBlacksIncrease: () => void;
+    onBlacksIncreaseMax: () => void;
+    onClarityDecreaseMax: () => void;
+    onClarityDecrease: () => void;
+    onClarityIncrease: () => void;
+    onClarityIncreaseMax: () => void;
+    onSharpnessDecreaseMax: () => void;
+    onSharpnessDecrease: () => void;
+    onSharpnessIncrease: () => void;
+    onSharpnessIncreaseMax: () => void;
+    expandedPanels: string[];
+    onPanelChange: (panel: string) => (event: React$1.SyntheticEvent, isExpanded: boolean) => void;
+}
+declare function HBulkAccordionColorAdjustment(props: Props$8): react_jsx_runtime.JSX.Element;
+
+type Preset = {
+    id: string;
+    name: string;
+};
+interface Props$7 {
+    presets: Preset[];
+    selectedPreset: string;
+    expandedPanels: string[];
+    presetMenuAnchorEl: null | HTMLElement;
+    activePresetMenuId: string | null;
+    isMenuOpen: boolean;
+    onPanelChange: (panel: string) => (event: React$1.SyntheticEvent, isExpanded: boolean) => void;
+    onSelectPreset: (event: SelectChangeEvent<string>) => void;
+    onPresetMenuClick: (event: React$1.MouseEvent<HTMLElement>, presetId: string) => void;
+    onPresetMenuClose: () => void;
+    onRemovePreset: () => void;
+    onRenamePreset: () => void;
+    onDeletePreset: () => void;
+    onOpenPresetModal: () => void;
+}
+declare function HBulkPreset(props: Props$7): react_jsx_runtime.JSX.Element;
+
+interface Props$6 {
+    modalName: string;
+    modalOpen: boolean;
+    modalTitle: string;
+    modalInformation: string;
+    children: React$1.ReactNode;
+    action?: React$1.ReactNode;
+    modalClose: () => void;
+    onConfirm: () => void;
+}
+declare function HModalEditorDekstop(props: Props$6): react_jsx_runtime.JSX.Element;
+
+interface Props$5 {
+    valueName: string;
+    setName: (event: React$1.ChangeEvent<HTMLInputElement>) => void;
+}
+declare function HTextField(props: Props$5): react_jsx_runtime.JSX.Element;
+interface PropsRename {
+    valueName: string;
+    setName: (event: React$1.ChangeEvent<HTMLInputElement>) => void;
+    onSaveRenamePreset: () => void;
+    onCancel: () => void;
+}
+declare function HTextFieldRename(props: PropsRename): react_jsx_runtime.JSX.Element;
+
+interface Props$4 {
+    onSaveWatermark: () => void;
+    onCancelWatermark: () => void;
+}
+declare function HWatermarkView(props: Props$4): react_jsx_runtime.JSX.Element;
+
+interface Props$3 {
+    modalName: string;
+    modalOpen: boolean;
+    modalTitle: string;
+    modalInformation?: string;
+    children: React$1.ReactNode;
+    action?: React$1.ReactNode;
+    modalClose: () => void;
+    onConfirm: () => void;
+}
+declare function HModalMobile(props: Props$3): react_jsx_runtime.JSX.Element;
+
+interface Props$2 {
+    anchorEl: null | HTMLElement;
+    isOpen: boolean;
+    onClose: () => void;
+    onRename: () => void;
+    onDelete: () => void;
+}
+declare function HPresetOptionsMenu(props: Props$2): react_jsx_runtime.JSX.Element;
+
+declare function HAlertInternetBox(): react_jsx_runtime.JSX.Element;
+declare function HAlertCopyBox(): react_jsx_runtime.JSX.Element;
+interface InternetConProps {
+    onClose: () => void;
+}
+declare function HAlertInternetConnectionBox(props: InternetConProps): react_jsx_runtime.JSX.Element;
+declare function HAlertPresetSave(): react_jsx_runtime.JSX.Element;
+
+interface ImageGalleryProps {
+    imageCollection: PhotoData[];
+    onToggleSelect: (photo: PhotoData) => void;
+}
+declare const AlbumImageGallery: React$1.FC<ImageGalleryProps>;
+
+interface Props$1 {
+    margin?: any;
+    index: number;
+    data: PhotoData;
+    direction: "row" | "column";
+    onToggleSelect: () => void;
+}
+declare const GalleryImageItem: (props: Props$1) => react_jsx_runtime.JSX.Element;
+
+interface EditorTask$1 {
+    id: string;
+    path: string;
+    frame: string | null;
+    adjustments?: Partial<AdjustmentValues>;
+    priority?: number;
+    abortSignal?: AbortSignal;
+}
+interface EditorResponse$1 {
+    id: string;
+    path: string;
+}
+declare class EditorProcessingService {
+    private processingQueue;
+    private isProcessing;
+    private processImage?;
+    private pendingProcessingTimeout?;
+    private statusChangeListeners;
+    constructor();
+    setProcessor(processImage: (task: EditorTask$1) => Promise<EditorResponse$1>): void;
+    addStatusChangeListener(listener: () => void): void;
+    removeStatusChangeListener(listener: () => void): void;
+    private notifyStatusChange;
+    requestProcessing(task: EditorTask$1): Promise<EditorResponse$1>;
+    private scheduleProcessing;
+    private processQueue;
+    private removeFromQueue;
+    getQueueStatus(): {
+        queueLength: number;
+        isProcessing: boolean;
+        hasProcessor: boolean;
+    };
+    clearQueue(): void;
+    cleanup(): void;
+}
+
+interface EditorContextValue {
+    isReady: boolean;
+    error: Error | null;
+    processingService: EditorProcessingService;
+    queueStatus: {
+        queueLength: number;
+        isProcessing: boolean;
+        hasProcessor: boolean;
+    };
+    editor: HonchoEditor | null;
+    loadImageFromUrl: ((url: string) => Promise<{
+        width: number;
+        height: number;
+    }>) | null;
+}
+interface EditorProviderProps {
+    children: React$1.ReactNode;
+    /** URL to the honcho-photo-editor.js script (defaults to '/honcho-photo-editor.js') */
+    scriptUrl?: string;
+    /** URL to the honcho-photo-editor.wasm file (defaults to '/honcho-photo-editor.wasm') */
+    wasmUrl?: string;
+}
+declare const EditorProvider: React$1.FC<EditorProviderProps>;
+declare const useEditorContext: () => EditorContextValue;
+
+interface UseImageProcessorProps {
+    photoId: string;
+    photoSrc: string;
+    enableEditor?: boolean;
+    adjustments?: Partial<AdjustmentValues>;
+    frame?: string | null;
+    priority?: 'high' | 'low';
+    abortSignal?: AbortSignal;
+}
+interface UseImageProcessorReturn {
+    processedImageSrc: string;
+    isProcessingComplete: boolean;
+    cancelProcessing: () => void;
+    isProcessing: boolean;
+}
+declare function useImageProcessor({ photoId, photoSrc, enableEditor, adjustments, frame, priority, abortSignal, }: UseImageProcessorProps): UseImageProcessorReturn;
+
+declare global {
+    interface Window {
+        HonchoEditor: new () => any;
+        HonchoEditorUtils: {
+            imageDataToBlob: (imageData: ImageData, format?: string, quality?: number) => Promise<Blob>;
+        };
+    }
+}
+interface EditorTask {
+    id: string;
+    path: string;
+    frame: string | null;
+    adjustments?: Partial<AdjustmentValues>;
+}
+interface EditorResponse {
+    id: string;
+    path: string;
+}
+interface UseEditorHeadlessOptions {
+    scriptUrl?: string;
+    wasmUrl?: string;
+}
+declare function useEditorHeadless(options?: UseEditorHeadlessOptions): {
+    editor: HonchoEditor | null;
+    isReady: boolean;
+    error: Error | null;
+    processImage: (task: EditorTask) => Promise<EditorResponse>;
+    loadImageFromUrl: (url: string) => Promise<{
+        width: number;
+        height: number;
+    }>;
+};
+
+interface Props {
+    isLoading: boolean;
+    onCancel: () => void;
+    onSubmit: () => void;
+}
+declare function HPresetDeleteDialog(props: Props): react_jsx_runtime.JSX.Element;
+
+interface ModalDialogProps {
+    isOpen: boolean;
+    isLoading?: boolean;
+    title?: string;
+    description?: string;
+    onCancel: () => void;
+    onSubmit: () => void;
+    cancelLabel?: string;
+    submitLabel?: string;
+}
+declare function ModalDialog(props: ModalDialogProps): react_jsx_runtime.JSX.Element;
+
+interface ModalRenameProps {
+    isOpen: boolean;
+    title?: string;
+    description?: string;
+    action?: React.ReactNode;
+    onCancel: () => void;
+    onSubmit: () => void;
+    cancelLabel?: string;
+    submitLabel?: string;
+    valueName: string;
+    setName: (event: React.ChangeEvent<HTMLInputElement>) => void;
+}
+declare function ModalRename(props: ModalRenameProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Configuration options for the adjustment history hook
+ */
+interface HistoryOptions {
+    /** Maximum number of history entries to keep. Use 'unlimited' for no limit */
+    maxSize?: number | 'unlimited';
+    /** Whether to enable batch mode for grouping multiple changes */
+    enableBatching?: boolean;
+    /** Enable development warnings for performance issues */
+    devWarnings?: boolean;
+}
+/**
+ * Information about the current history state
+ */
+interface HistoryInfo {
+    /** Whether undo operation is available */
+    canUndo: boolean;
+    /** Whether redo operation is available */
+    canRedo: boolean;
+    /** Current position in history (0-based index) */
+    currentIndex: number;
+    /** Total number of states in history */
+    totalStates: number;
+    /** Current size of history in memory */
+    historySize: number;
+    /** Whether batch mode is currently active */
+    isBatchMode: boolean;
+}
+/**
+ * Actions available for history management
+ */
+interface HistoryActions {
+    /** Add a new adjustment state to history */
+    pushState: (state: AdjustmentState) => void;
+    /** Undo to previous adjustment state */
+    undo: () => void;
+    /** Redo to next adjustment state */
+    redo: () => void;
+    /** Jump to specific index in history */
+    jumpToIndex: (index: number) => void;
+    /** Clear all history and start fresh */
+    clearHistory: () => void;
+    /** Get a copy of the entire history array */
+    getHistory: () => AdjustmentState[];
+    /** Trim history to specified size, keeping most recent entries */
+    trimHistory: (keepLast: number) => void;
+    /** Sync history from backend using getEditorHistory */
+    syncFromBackend: () => Promise<void>;
+}
+/**
+ * Configuration actions for runtime adjustment
+ */
+interface HistoryConfig {
+    /** Set maximum history size */
+    setMaxSize: (size: number | 'unlimited') => void;
+    /** Enable or disable batch mode */
+    setBatchMode: (enabled: boolean, forceHistory?: boolean) => Promise<void>;
+    /** Get current memory usage estimate */
+    getMemoryUsage: () => number;
+}
+/**
+ * Return type for the useAdjustmentHistory hook
+ */
+interface UseAdjustmentHistoryReturn {
+    /** Current adjustment state value */
+    currentState: AdjustmentState;
+    /** Current index in history */
+    currentIndex: number;
+    /** Information about history state */
+    historyInfo: HistoryInfo;
+    /** Available history actions */
+    actions: HistoryActions;
+    /** Configuration options */
+    config: HistoryConfig;
+}
+/**
+ * Advanced hook for managing AdjustmentState history with undo/redo functionality.
+ *
+ * Features:
+ * - Unlimited or configurable history size
+ * - Batch mode for grouping multiple changes into single undo operations
+ * - Memory usage monitoring and optimization
+ * - Internal stabilization to prevent re-render issues
+ * - Jump to any point in history
+ * - Automatic AdjustmentState comparison
+ *
+ * @param initialState - The initial AdjustmentState value
+ * @param controller - Controller for backend operations (optional)
+ * @param firebaseUid - Firebase UID for backend operations (optional)
+ * @param currentImageId - Current image ID for backend operations (optional)
+ * @param options - Configuration options for history behavior
+ * @returns Object with current state, history info, actions, and config
+ */
+declare function useAdjustmentHistory(initialState: AdjustmentState, controller?: Controller, firebaseUid?: string, currentImageId?: string, options?: HistoryOptions): UseAdjustmentHistoryReturn;
+
+/**
+ * Configuration options for the paging hook
+ */
+interface PagingOptions {
+    /** Enable development warnings for debugging */
+    devWarnings?: boolean;
+    /** Auto-load first page on hook initialization */
+    autoLoad?: boolean;
+    /** Reset pagination when dependencies change */
+    autoReset?: boolean;
+}
+/**
+ * Information about the current paging state
+ */
+interface PagingInfo {
+    /** Whether images are currently being loaded */
+    isLoading: boolean;
+    /** Whether more pages are being loaded */
+    isLoadingMore: boolean;
+    /** Error message if any operation failed */
+    error: string | null;
+    /** Current page number */
+    currentPage: number;
+    /** Whether there are more pages to load */
+    hasMore: boolean;
+    /** Total number of images loaded */
+    totalImages: number;
+    /** Whether the hook has been initialized */
+    isInitialized: boolean;
+}
+/**
+ * Actions available for paging management
+ */
+interface PagingActions {
+    /** Load more images (next page) - only one instance can run at a time */
+    loadMore: () => Promise<void>;
+    /** Refresh/reload from first page */
+    refresh: () => Promise<void>;
+    /** Reset pagination state */
+    reset: () => void;
+}
+/**
+ * Return type for the usePaging hook
+ */
+interface UsePagingReturn {
+    /** Current list of images */
+    images: Gallery[];
+    /** Information about paging state */
+    info: PagingInfo;
+    /** Available paging actions */
+    actions: PagingActions;
+}
+/**
+ * Hook for managing paginated image loading with ControllerBulk.
+ *
+ * **Key Features:**
+ * - **Paginated Loading**: Handles page-by-page image loading
+ * - **State Management**: Maintains image list and pagination state
+ * - **Load More**: Seamlessly loads and appends next pages
+ * - **Mutation**: Update specific images without full reload
+ * - **Error Handling**: Provides error states for failed operations
+ * - **Auto-loading**: Optional automatic first page loading
+ *
+ * **Typical Usage:**
+ * ```typescript
+ * const { images, info, actions } = usePaging(controller, firebaseUid, eventId, {
+ *   autoLoad: true,
+ *   autoReset: true
+ * });
+ *
+ * // Load more images
+ * await actions.loadMore();
+ *
+ * // Refresh from beginning
+ * await actions.refresh();
+ *
+ * // Update specific image
+ * actions.mutateImage(imageId, (img) => ({ ...img, isSelected: true }));
+ * ```
+ *
+ * @param controller - Backend controller for API communication
+ * @param firebaseUid - User identifier for backend operations
+ * @param eventId - Event identifier for image list
+ * @param options - Configuration options
+ * @returns Object with images, info, and actions
+ */
+declare function usePaging(controller: Controller | null, firebaseUid: string, eventId: string, options?: PagingOptions): UsePagingReturn;
+
+interface Colors {
+    onSurface: string;
+    surface: string;
+    onSurfaceVariant: string;
+    onSurfaceVariant1: string;
+    outlineVariant: string;
+    error: string;
+    onBackground: string;
+    background: string;
+}
+declare function useColors(): Colors;
+
+interface HonchoTypography {
+    displayLarge: FontStyle;
+    displayMedium: FontStyle;
+    displaySmall: FontStyle;
+    headlineLarge: FontStyle;
+    headlineMedium: FontStyle;
+    headlineSmall: FontStyle;
+    titleLarge: FontStyle;
+    titleMedium: FontStyle;
+    titleSmall: FontStyle;
+    bodyLarge: FontStyle;
+    bodyMedium: FontStyle;
+    bodySmall: FontStyle;
+    labelLarge: FontStyle;
+    labelMedium: FontStyle;
+    labelSmall: FontStyle;
+}
+interface FontStyle {
+    fontSize: number;
+    lineHeight: string;
+    fontWeight: number;
+    letterSpacing: string;
+}
+declare function useHonchoTypography(): HonchoTypography;
+
+declare function useIsMobile(): boolean;
+
+export { type AdjustmentRange, type AdjustmentRanges, type AdjustmentState, type AdjustmentValues, AlbumImageGallery, type BatchAdjustmentState, type BatchHistoryActions, type BatchHistoryConfig, type BatchHistoryInfo, type ColorAdjustment, type Content, type Controller, type CreateEditorTaskRequest, type EditorHistoryEntry, EditorProvider, type Gallery, GalleryImageItem, type GetGalleryUpdateTimestampResponse, type GetHistoryResponse, HAccordionColorAdjustment, HAccordionPreset, HAlertCopyBox, HAlertInternetBox, HAlertInternetConnectionBox, HAlertPresetSave, HBaseDialog, HBulkAccordionColorAdjustment, HBulkPreset, HDialogCopy, HDialogForPreset, HDialogPreset, HFooter, HHeaderEditor, HImageEditorBulkDekstop, HImageEditorBulkMobile, HImageEditorDesktop, HImageEditorMobile, ModalDialog as HModalDialog, HModalEditorDekstop, HModalMobile, ModalRename as HModalRename, HPresetDeleteDialog, HPresetOptionsMenu, HTextField, HTextFieldRename, HWatermarkView, type HistoryActions, type HistoryConfig, type HistoryInfo, HonchoEditor, type ImageAdjustmentConfig, type ImageItem, type ImageSize, type PagingActions, type PagingInfo, type PagingOptions, type PhotoData, type Preset$4 as Preset, type PresetActions, type PresetInfo, type PresetOptions, type UseAdjustmentHistoryBatchReturn, type UseAdjustmentHistoryReturn, type UsePagingReturn, type UsePresetReturn, useAdjustmentHistory, useAdjustmentHistoryBatch, useColors, useEditorContext, useEditorHeadless, useHonchoEditorBulk, useHonchoEditorSingle, useHonchoTypography, useImageProcessor, useIsMobile, usePaging, usePreset };