@umituz/react-native-design-system 4.25.99 → 4.25.100

package/dist/haptics/index.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Haptics Domain - Barrel Export
+ *
+ * Provides haptic feedback (vibration) using expo-haptics.
+ * Universal domain - enabled by default for UX improvement.
+ *
+ * @domain haptics
+ * @enabled true (All apps - UX improvement)
+ *
+ * ARCHITECTURE:
+ * - Domain Layer: Entities (haptic types, patterns, utilities)
+ * - Infrastructure Layer: Services (HapticService)
+ * - Presentation Layer: Hooks (useHaptics)
+ *
+ * DEPENDENCIES:
+ * - expo-haptics (vibration patterns)
+ *
+ * FEATURES:
+ * - Impact feedback (light, medium, heavy)
+ * - Notification feedback (success, warning, error)
+ * - Selection feedback (pickers, sliders)
+ * - Custom haptic patterns
+ * - Convenience methods for common interactions
+ *
+ * USAGE:
+ *
+ * Basic Haptics:
+ * ```typescript
+ * import { useHaptics } from '@umituz/react-native-haptics';
+ *
+ * const haptics = useHaptics();
+ *
+ * // Button press
+ * <TouchableOpacity onPress={() => haptics.buttonPress()}>
+ *   <Text>Click Me</Text>
+ * </TouchableOpacity>
+ *
+ * // Success feedback
+ * const handleSave = async () => {
+ *   await saveData();
+ *   haptics.success();
+ * };
+ *
+ * // Error feedback
+ * haptics.error();
+ * ```
+ *
+ * Selection Change (Sliders, Pickers):
+ * ```typescript
+ * import { useHaptics } from '@umituz/react-native-haptics';
+ *
+ * const haptics = useHaptics();
+ *
+ * <Slider
+ *   value={value}
+ *   onValueChange={(val) => {
+ *     setValue(val);
+ *     haptics.selectionChange();
+ *   }}
+ * />
+ * ```
+ *
+ * Custom Patterns:
+ * ```typescript
+ * import { useHaptics } from '@umituz/react-native-haptics';
+ *
+ * const haptics = useHaptics();
+ *
+ * // Impact with specific style
+ * haptics.impact('heavy');
+ *
+ * // Notification with specific type
+ * haptics.notification('warning');
+ *
+ * // Custom pattern
+ * haptics.pattern('long_press');
+ * ```
+ *
+ * Direct Service Usage (Rare):
+ * ```typescript
+ * import { HapticService } from '@umituz/react-native-haptics';
+ *
+ * // Use when you can't use hooks (outside components)
+ * await HapticService.buttonPress();
+ * await HapticService.success();
+ * ```
+ *
+ * Common Patterns:
+ * ```typescript
+ * import { useHaptics } from '@umituz/react-native-haptics';
+ *
+ * const haptics = useHaptics();
+ *
+ * // Button press (light impact)
+ * haptics.buttonPress();
+ *
+ * // Success (notification feedback)
+ * haptics.success();
+ *
+ * // Error (notification feedback)
+ * haptics.error();
+ *
+ * // Warning (notification feedback)
+ * haptics.warning();
+ *
+ * // Delete (medium impact)
+ * haptics.delete();
+ *
+ * // Refresh (medium impact)
+ * haptics.refresh();
+ *
+ * // Selection change (selection feedback)
+ * haptics.selectionChange();
+ *
+ * // Long press (heavy impact)
+ * haptics.longPress();
+ * ```
+ *
+ * Utilities:
+ * ```typescript
+ * import { HapticUtils } from '@umituz/react-native-haptics';
+ *
+ * // Get impact style for pattern
+ * const style = HapticUtils.getImpactForPattern('button_press'); // 'light'
+ *
+ * // Get notification type for pattern
+ * const type = HapticUtils.getNotificationForPattern('success'); // 'success'
+ *
+ * // Check if pattern should use notification
+ * const shouldUse = HapticUtils.shouldUseNotification('success'); // true
+ * ```
+ *
+ * BENEFITS:
+ * - Improved UX with tactile feedback
+ * - Consistent haptic patterns across app
+ * - Silent failure (no crashes if unsupported)
+ * - Platform-agnostic (iOS + Android)
+ * - Easy integration in any component
+ * - Works across all apps
+ *
+ * USE CASES:
+ * - Button presses
+ * - Success confirmations
+ * - Error alerts
+ * - Selection changes (sliders, pickers)
+ * - Delete actions
+ * - Refresh actions
+ * - Long press gestures
+ * - Form validation feedback
+ *
+ * @see https://docs.expo.dev/versions/latest/sdk/haptics/
+ */
+export type { ImpactStyle, NotificationType, HapticPattern, } from './domain/entities/Haptic';
+export { HAPTIC_CONSTANTS, isImpactStyle, isNotificationType, isHapticPattern, } from './domain/entities/Haptic';
+export { HapticService } from './infrastructure/services/HapticService';
+export { useHaptics } from './presentation/hooks/useHaptics';

package/dist/haptics/infrastructure/services/HapticService.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Haptics Domain - Haptic Service
+ *
+ * Service for haptic feedback using expo-haptics (optional peer dep).
+ * Falls back to noop when expo-haptics is not installed or haptics are disabled.
+ *
+ * LAZY LOADING:
+ * expo-haptics is only required at runtime when a haptic is triggered AND enabled.
+ * Apps that don't need haptics pay zero cost — no require() is ever called.
+ *
+ * USAGE:
+ * // Opt out entirely (e.g. tablet apps, web, or apps without expo-haptics):
+ * HapticService.configure({ enabled: false })
+ *
+ * // Opt in (default):
+ * HapticService.configure({ enabled: true })
+ */
+import type { ImpactStyle, NotificationType, HapticPattern } from '../../domain/entities/Haptic';
+export declare class HapticService {
+    /**
+     * Configure haptics at the app level.
+     * Call once at startup — before any haptic is triggered.
+     *
+     * @param enabled - false to silently disable all haptics (no expo-haptics required).
+     *                  Defaults to true.
+     */
+    static configure({ enabled }: {
+        enabled: boolean;
+    }): void;
+    static impact(style?: ImpactStyle): Promise<void>;
+    static notification(type: NotificationType): Promise<void>;
+    static selection(): Promise<void>;
+    static pattern(pattern: HapticPattern): Promise<void>;
+    static buttonPress(): Promise<void>;
+    static success(): Promise<void>;
+    static error(): Promise<void>;
+    static warning(): Promise<void>;
+    static delete(): Promise<void>;
+    static refresh(): Promise<void>;
+    static selectionChange(): Promise<void>;
+    static longPress(): Promise<void>;
+    static rigid(): Promise<void>;
+    static soft(): Promise<void>;
+}

package/dist/haptics/presentation/hooks/useHaptics.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Haptics Domain - useHaptics Hook
+ *
+ * React hook for haptic feedback.
+ * Provides vibration patterns for common interactions.
+ *
+ * @domain haptics
+ * @layer presentation/hooks
+ */
+import type { ImpactStyle, NotificationType, HapticPattern } from '../../domain/entities/Haptic';
+/**
+ * useHaptics hook for haptic feedback
+ *
+ * USAGE:
+ * ```typescript
+ * const haptics = useHaptics();
+ *
+ * // Common patterns (convenience methods)
+ * <TouchableOpacity onPress={() => haptics.buttonPress()}>
+ *   <Text>Click Me</Text>
+ * </TouchableOpacity>
+ *
+ * // Success feedback
+ * const handleSuccess = async () => {
+ *   await saveData();
+ *   haptics.success();
+ * };
+ *
+ * // Error feedback
+ * const handleError = () => {
+ *   haptics.error();
+ * };
+ *
+ * // Selection change (sliders, pickers)
+ * <Slider onValueChange={() => haptics.selectionChange()} />
+ *
+ * // Custom patterns
+ * haptics.pattern('long_press');
+ * haptics.impact('heavy');
+ * haptics.notification('warning');
+ * ```
+ */
+export declare const useHaptics: () => {
+    impact: (style?: ImpactStyle) => Promise<void>;
+    notification: (type: NotificationType) => Promise<void>;
+    selection: () => Promise<void>;
+    pattern: (patternType: HapticPattern) => Promise<void>;
+    buttonPress: () => Promise<void>;
+    success: () => Promise<void>;
+    error: () => Promise<void>;
+    warning: () => Promise<void>;
+    delete: () => Promise<void>;
+    refresh: () => Promise<void>;
+    selectionChange: () => Promise<void>;
+    longPress: () => Promise<void>;
+};

package/dist/image/domain/entities/ImageConstants.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Image Domain - Configuration Constants
+ */
+import { SaveFormat } from "./ImageTypes";
+export interface ImageConfiguration {
+    readonly maxWidth: number;
+    readonly maxHeight: number;
+    readonly defaultQuality: number;
+    readonly thumbnailSize: number;
+    readonly compressQuality: {
+        readonly low: number;
+        readonly medium: number;
+        readonly high: number;
+    };
+    readonly format: {
+        readonly jpeg: SaveFormat;
+        readonly png: SaveFormat;
+        readonly webp: SaveFormat;
+    };
+}
+export declare const IMAGE_CONSTANTS: ImageConfiguration;

package/dist/image/domain/entities/ImageFilterTypes.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Image Domain - Filter Types
+ */
+export declare enum ImageFilterType {
+    BLUR = "blur",
+    SHARPEN = "sharpen",
+    BRIGHTNESS = "brightness",
+    CONTRAST = "contrast",
+    SATURATION = "saturation",
+    SEPIA = "sepia",
+    GRAYSCALE = "grayscale",
+    VINTAGE = "vintage",
+    VIGNETTE = "vignette"
+}
+export interface ImageFilterOptions {
+    intensity?: number;
+    radius?: number;
+    amount?: number;
+}
+export interface ImageFilter {
+    type: ImageFilterType;
+    options?: ImageFilterOptions;
+}
+export interface ImageColorAdjustment {
+    brightness?: number;
+    contrast?: number;
+    saturation?: number;
+    hue?: number;
+}
+export interface ImageQualityMetrics {
+    sharpness: number;
+    brightness: number;
+    contrast: number;
+    colorfulness: number;
+    overallQuality: number;
+}
+export interface ImageColorPalette {
+    dominant: string[];
+    palette: Array<{
+        color: string;
+        percentage: number;
+        population: number;
+    }>;
+}
+export interface ImageMetadataExtended {
+    format: string;
+    size: number;
+    dimensions: {
+        width: number;
+        height: number;
+    };
+    colorSpace: string;
+    hasAlpha: boolean;
+    orientation: number;
+    dpi?: number;
+    creationDate?: Date;
+    modificationDate?: Date;
+    gps?: {
+        latitude: number;
+        longitude: number;
+    };
+    camera?: {
+        make?: string;
+        model?: string;
+        iso?: number;
+        flash?: boolean;
+        focalLength?: number;
+    };
+}

package/dist/image/domain/entities/ImageTemplateTypes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Image Template Types
+ */
+export interface ImageTemplate {
+    id: string;
+    name: string;
+    url: string;
+}
+export interface MemeTemplateOptions {
+    templateKey: string;
+    topText?: string;
+    bottomText?: string;
+    style?: string;
+    width?: number;
+    height?: number;
+}

package/dist/image/domain/entities/ImageTypes.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Image Domain - Core Type Definitions
+ */
+export declare enum ImageFormat {
+    JPEG = "jpeg",
+    PNG = "png",
+    WEBP = "webp"
+}
+export type SaveFormat = 'jpeg' | 'png' | 'webp';
+export declare enum ImageOrientation {
+    PORTRAIT = "portrait",
+    LANDSCAPE = "landscape",
+    SQUARE = "square"
+}
+export interface ImageDimensions {
+    width: number;
+    height: number;
+}
+export interface ImageCropArea {
+    originX: number;
+    originY: number;
+    width: number;
+    height: number;
+}
+export interface ImageFlipOptions {
+    vertical?: boolean;
+    horizontal?: boolean;
+}
+export interface ImageManipulateAction {
+    resize?: Partial<ImageDimensions>;
+    crop?: ImageCropArea;
+    rotate?: number;
+    flip?: ImageFlipOptions;
+}
+export interface ImageSaveOptions {
+    format?: SaveFormat;
+    compress?: number;
+    base64?: boolean;
+}
+export interface ImageManipulationResult {
+    uri: string;
+    width: number;
+    height: number;
+    base64?: string;
+}
+export interface ImageMetadata extends ImageDimensions {
+    uri: string;
+    format?: ImageFormat;
+    size?: number;
+    orientation?: ImageOrientation;
+}
+export interface ImageViewerItem {
+    uri: string;
+    title?: string;
+    description?: string;
+    width?: number;
+    height?: number;
+}
+export interface ImageGalleryOptions {
+    index?: number;
+    backgroundColor?: string;
+    swipeToCloseEnabled?: boolean;
+    doubleTapToZoomEnabled?: boolean;
+    onDismiss?: () => void;
+    onIndexChange?: (index: number) => void;
+}
+export interface ImageOperationResult {
+    success: boolean;
+    uri?: string;
+    error?: string;
+    width?: number;
+    height?: number;
+}

package/dist/image/domain/entities/ValidationResult.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Validation Result Interface
+ * Represents the outcome of a validation operation
+ */
+export interface ValidationResult {
+    /**
+     * Whether the validation passed
+     */
+    isValid: boolean;
+    /**
+     * Error message if validation failed
+     */
+    error?: string;
+}

package/dist/image/domain/utils/ImageUtils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Image Domain - Utility Functions
+ */
+import { ImageFormat, ImageOrientation, ImageDimensions, ImageCropArea } from "../entities/ImageTypes";
+export declare class ImageUtils {
+    static getOrientation(width: number, height: number): ImageOrientation;
+    static getAspectRatio(width: number, height: number): number;
+    static fitToSize(width: number, height: number, maxWidth: number, maxHeight: number): ImageDimensions;
+    static getThumbnailSize(width: number, height: number, thumbnailSize?: number): ImageDimensions;
+    static isValidImageUri(uri: string): boolean;
+    static getFormatFromUri(uri: string): ImageFormat | null;
+    static getExtensionFromFormat(format: ImageFormat): string;
+    static getSquareCrop(width: number, height: number): ImageCropArea;
+    static formatFileSize(bytes: number): string;
+    static needsCompression(bytes: number, maxSizeMB?: number): boolean;
+}

package/dist/image/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @umituz/react-native-image - Public API
+ *
+ * React Native image manipulation and viewing
+ * Resize, crop, rotate, flip, compress, gallery viewer
+ *
+ * Usage:
+ *   import { useImage, ImageGallery, ImageUtils } from '@umituz/react-native-image';
+ */
+export type { ImageManipulateAction, ImageSaveOptions, ImageManipulationResult, ImageMetadata, ImageViewerItem, ImageGalleryOptions, ImageOperationResult, SaveFormat, ImageDimensions, ImageCropArea, ImageFlipOptions, } from './domain/entities/ImageTypes';
+export type { ImageTemplate, MemeTemplateOptions, } from './domain/entities/ImageTemplateTypes';
+export { ImageFormat, ImageOrientation, } from './domain/entities/ImageTypes';
+export { IMAGE_CONSTANTS } from './domain/entities/ImageConstants';
+export { ImageUtils } from './domain/utils/ImageUtils';
+export type { ImageFilterOptions, ImageColorAdjustment, ImageQualityMetrics, ImageColorPalette, ImageMetadataExtended, } from './domain/entities/ImageFilterTypes';
+export { ImageFilterType, } from './domain/entities/ImageFilterTypes';
+export { ImageTransformService } from './infrastructure/services/ImageTransformService';
+export { ImageConversionService } from './infrastructure/services/ImageConversionService';
+export { ImageStorageService } from './infrastructure/services/ImageStorageService';
+export { ImageViewerService, type ImageViewerConfig, } from './infrastructure/services/ImageViewerService';
+export { ImageBatchService, type BatchProcessingOptions, type BatchProcessingResult } from './infrastructure/services/ImageBatchService';
+export type { BatchOperation } from './infrastructure/types/BatchTypes';
+export { ImageEnhanceService, type AutoEnhancementOptions, type EnhancementResult } from './infrastructure/services/ImageEnhanceService';
+export { ImageMetadataService, type ImageMetadataExtractionOptions } from './infrastructure/services/ImageMetadataService';
+export { ImageQualityPresetService, type QualityPreset, type QualityPresets, IMAGE_QUALITY_PRESETS } from './infrastructure/utils/ImageQualityPresets';
+export { ImageTemplateService } from './infrastructure/services/ImageTemplateService';
+export { ImageGallery, type ImageGalleryProps } from './presentation/components/ImageGallery';
+export { TextEditorSheet, type TextEditorSheetProps } from './presentation/components/editor/TextEditorSheet';
+export { StickerPickerSheet, type StickerPickerSheetProps } from './presentation/components/editor/StickerPickerSheet';
+export { FilterPickerSheet, type FilterPickerSheetProps } from './presentation/components/editor/FilterPickerSheet';
+export { useImage } from './presentation/hooks/useImage';
+export { useImageTransform } from './presentation/hooks/useImageTransform';
+export { useImageConversion } from './presentation/hooks/useImageConversion';
+export { useImageGallery, type UseImageGalleryReturn, } from './presentation/hooks/useImageGallery';
+export { useImageBatch } from './presentation/hooks/useImageBatch';
+export { useImageEnhance } from './presentation/hooks/useImageEnhance';
+export { useImageMetadata } from './presentation/hooks/useImageMetadata';
+export type { ValidationResult } from './domain/entities/ValidationResult';
+export { getFileExtension, getMimeTypeFromExtension, getMimeTypeFromDataUrl, validateImageMimeType, validateImageExtension, validateImageDataUrl, } from './infrastructure/utils/validation/mime-type-validator';
+export { validateImageUri, getImageMimeType, } from './infrastructure/utils/validation/image-validator';
+export { IMAGE_MIME_TYPES, SUPPORTED_IMAGE_MIME_TYPES, EXTENSION_TO_MIME_TYPE, MIME_TYPE_TO_EXTENSION, } from './infrastructure/utils/validation/mime-types.constants';
+export { AtomicImage } from '../atoms/image/AtomicImage';
+export type { AtomicImageProps } from '../atoms/image/AtomicImage';

package/dist/image/infrastructure/services/ImageBatchService.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Image Infrastructure - Batch Processing Service
+ *
+ * Handles processing multiple images concurrently with progress tracking
+ */
+import type { ImageManipulationResult } from '../../domain/entities/ImageTypes';
+import type { BatchOperation } from '../types/BatchTypes';
+export interface BatchProcessingOptions {
+    concurrency?: number;
+    onProgress?: (completed: number, total: number, currentUri?: string) => void;
+    onError?: (error: Error, uri: string) => void;
+}
+export interface BatchProcessingResult {
+    successful: Array<{
+        uri: string;
+        result: ImageManipulationResult;
+    }>;
+    failed: Array<{
+        uri: string;
+        error: Error;
+    }>;
+    totalProcessed: number;
+    successCount: number;
+    failureCount: number;
+}
+export declare class ImageBatchService {
+    static processBatch(operations: BatchOperation[], options?: BatchProcessingOptions): Promise<BatchProcessingResult>;
+    static resizeBatch(uris: string[], width?: number, height?: number, options?: BatchProcessingOptions & {
+        saveOptions?: Record<string, unknown>;
+    }): Promise<BatchProcessingResult>;
+    static compressBatch(uris: string[], quality?: number, options?: BatchProcessingOptions): Promise<BatchProcessingResult>;
+}

package/dist/image/infrastructure/services/ImageConversionService.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Image Infrastructure - Conversion Service
+ *
+ * Handles format conversion, compression, and thumbnail generation
+ */
+import type { ImageSaveOptions, ImageManipulationResult, SaveFormat } from '../../domain/entities/ImageTypes';
+export declare class ImageConversionService {
+    static compress(uri: string, quality?: number): Promise<ImageManipulationResult>;
+    static convertFormat(uri: string, format: SaveFormat, quality?: number): Promise<ImageManipulationResult>;
+    static createThumbnail(uri: string, size?: number, options?: ImageSaveOptions): Promise<ImageManipulationResult>;
+}

package/dist/image/infrastructure/services/ImageEnhanceService.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Image Infrastructure - Enhance Service
+ *
+ * AI-powered image enhancement and automatic adjustments
+ */
+import type { ImageManipulationResult } from '../../domain/entities/ImageTypes';
+import type { ImageQualityMetrics, ImageColorAdjustment } from '../../domain/entities/ImageFilterTypes';
+export interface AutoEnhancementOptions {
+    enhanceBrightness?: boolean;
+    enhanceContrast?: boolean;
+    enhanceColor?: boolean;
+    reduceNoise?: boolean;
+    sharpen?: boolean;
+    targetQuality?: number;
+}
+export interface EnhancementResult {
+    originalMetrics: ImageQualityMetrics;
+    enhancedMetrics: ImageQualityMetrics;
+    appliedAdjustments: ImageColorAdjustment;
+    improvementScore: number;
+}
+export declare class ImageEnhanceService {
+    static analyzeImage(uri: string): Promise<ImageQualityMetrics>;
+    static autoEnhance(uri: string, options?: AutoEnhancementOptions): Promise<EnhancementResult>;
+    static enhancePortrait(uri: string): Promise<ImageManipulationResult>;
+    static enhanceLandscape(uri: string): Promise<ImageManipulationResult>;
+}

package/dist/image/infrastructure/services/ImageMetadataService.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Image Infrastructure - Metadata Service
+ *
+ * Extracts and manages image metadata including EXIF data
+ */
+import type { ImageMetadataExtended } from '../../domain/entities/ImageFilterTypes';
+export interface ImageMetadataExtractionOptions {
+    includeExif?: boolean;
+    includeGPS?: boolean;
+    includeCamera?: boolean;
+}
+export declare class ImageMetadataService {
+    static extractMetadata(uri: string, options?: ImageMetadataExtractionOptions): Promise<ImageMetadataExtended>;
+    static getBasicInfo(uri: string): Promise<{
+        format: string;
+        size: number;
+        dimensions: {
+            width: number;
+            height: number;
+        };
+    }>;
+    static hasMetadata(uri: string): Promise<boolean>;
+}

package/dist/image/infrastructure/services/ImageStorageService.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Image Infrastructure - Storage Service
+ *
+ * Handles saving images to the device filesystem
+ */
+export declare class ImageStorageService {
+    static saveImage(uri: string, filename?: string): Promise<string>;
+}

package/dist/image/infrastructure/services/ImageTemplateService.d.ts

@@ -0,0 +1,20 @@
+import { MemeTemplateOptions } from '../../domain/entities/ImageTemplateTypes';
+/**
+ * ImageTemplateService
+ *
+ * Provides utilities for generating image template URLs (e.g. Memegen.link)
+ */
+export declare class ImageTemplateService {
+    /**
+     * Generates a meme URL for a given template and texts
+     *
+     * @param options Meme configuration (templateKey, topText, bottomText)
+     * @param baseUrl Optional base URL for the image generation service
+     * @returns Formatted image URL
+     */
+    static generateMemeUrl(options: MemeTemplateOptions, baseUrl?: string): string;
+    /**
+     * Extracts template key from a memegen.link URL or filename
+     */
+    static extractTemplateKey(url: string): string;
+}

package/dist/image/infrastructure/services/ImageTransformService.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Image Infrastructure - Transform Service
+ *
+ * Handles geometric transformations: resize, crop, rotate, flip
+ */
+import type { ImageManipulateAction, ImageSaveOptions, ImageManipulationResult, ImageCropArea, ImageFlipOptions } from '../../domain/entities/ImageTypes';
+export declare class ImageTransformService {
+    static resize(uri: string, width?: number, height?: number, options?: ImageSaveOptions): Promise<ImageManipulationResult>;
+    static crop(uri: string, cropArea: ImageCropArea, options?: ImageSaveOptions): Promise<ImageManipulationResult>;
+    static rotate(uri: string, degrees: number, options?: ImageSaveOptions): Promise<ImageManipulationResult>;
+    static flip(uri: string, flip: ImageFlipOptions, options?: ImageSaveOptions): Promise<ImageManipulationResult>;
+    static manipulate(uri: string, action: ImageManipulateAction, options?: ImageSaveOptions): Promise<ImageManipulationResult>;
+    static resizeToFit(uri: string, maxWidth: number, maxHeight: number, options?: ImageSaveOptions): Promise<ImageManipulationResult>;
+    static cropToSquare(uri: string, width: number, height: number, options?: ImageSaveOptions): Promise<ImageManipulationResult>;
+}