@umituz/react-native-ai-generation-content 1.12.23 → 1.12.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.12.23",
+  "version": "1.12.24",
   "description": "Provider-agnostic AI generation orchestration for React Native",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/features/audio-generation/domain/entities.ts

@@ -0,0 +1,39 @@
+/**
+ * Audio Generation Domain Entities
+ */
+
+export interface AudioGenerationConfig {
+    /**
+     * Duration of the audio in seconds
+     */
+    duration?: number;
+
+    /**
+     * Voice ID or style
+     */
+    voiceId?: string;
+}
+
+export interface AudioGenerationRequest {
+    /**
+     * The text prompt or description for audio generation
+     */
+    prompt: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: AudioGenerationConfig;
+}
+
+export interface AudioGenerationResult {
+    /**
+     * The generated audio file URL
+     */
+    audioUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

package/src/features/audio-generation/index.ts

@@ -0,0 +1,2 @@
+export * from './domain/entities';
+export * from './presentation/hooks';

package/src/features/audio-generation/presentation/hooks.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useState, useCallback } from 'react';
+import { useGeneration } from '../../../presentation/hooks/use-generation';
+import { AudioGenerationRequest, AudioGenerationResult } from '../domain/entities';
+
+export interface UseAudioGenerationReturn {
+    generateAudio: (request: AudioGenerationRequest) => Promise<AudioGenerationResult>;
+    isGenerating: boolean;
+    result: AudioGenerationResult | null;
+    error: Error | null;
+}
+
+export const useAudioGeneration = (): UseAudioGenerationReturn => {
+    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
+    const [result, setResult] = useState<AudioGenerationResult | null>(null);
+
+    const generateAudio = useCallback(async (request: AudioGenerationRequest) => {
+        await generate(request as any);
+
+        if (genResult?.data) {
+            setResult(genResult.data as AudioGenerationResult);
+            return genResult.data as AudioGenerationResult;
+        }
+
+        throw new Error('Audio generation failed to return a result');
+    }, [generate, genResult]);
+
+    return {
+        generateAudio,
+        isGenerating,
+        result,
+        error: error as any,
+    };
+};

package/src/features/colorization/domain/entities.ts

@@ -0,0 +1,46 @@
+/**
+ * Colorization Domain Entities
+ */
+
+export interface ColorizationConfig {
+    /**
+     * Guidance for color palette (e.g., "vintage", "modern", "warm")
+     */
+    palette?: string;
+
+    /**
+     * Saturation boost factor
+     * @default 1.0
+     */
+    saturation?: number;
+}
+
+export interface ColorizationRequest {
+    /**
+     * The black and white image to colorize.
+     * Can be a Base64 string or a remote URL.
+     */
+    image: string;
+
+    /**
+     * Optional prompt to guide colorization (e.g. "sunny day")
+     */
+    prompt?: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: ColorizationConfig;
+}
+
+export interface ColorizationResult {
+    /**
+     * The colorized image URL or Base64
+     */
+    imageUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

package/src/features/colorization/index.ts

@@ -0,0 +1,2 @@
+export * from './domain/entities';
+export * from './presentation/hooks';

package/src/features/colorization/presentation/hooks.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useState, useCallback } from 'react';
+import { useGeneration } from '../../../presentation/hooks/use-generation';
+import { ColorizationRequest, ColorizationResult } from '../domain/entities';
+
+export interface UseColorizationReturn {
+    colorize: (request: ColorizationRequest) => Promise<ColorizationResult>;
+    isColorizing: boolean;
+    result: ColorizationResult | null;
+    error: Error | null;
+}
+
+export const useColorization = (): UseColorizationReturn => {
+    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
+    const [result, setResult] = useState<ColorizationResult | null>(null);
+
+    const colorize = useCallback(async (request: ColorizationRequest) => {
+        await generate(request as any);
+
+        if (genResult?.data) {
+            setResult(genResult.data as ColorizationResult);
+            return genResult.data as ColorizationResult;
+        }
+
+        throw new Error('Colorization failed to return a result');
+    }, [generate, genResult]);
+
+    return {
+        colorize,
+        isColorizing: isGenerating,
+        result,
+        error: error as any,
+    };
+};

package/src/features/face-swap/domain/entities.ts

@@ -0,0 +1,48 @@
+/**
+ * Face Swap Domain Entities
+ */
+
+export interface FaceSwapConfig {
+    /**
+     * Enhance the face details after swapping
+     * @default true
+     */
+    enhanceFace?: boolean;
+
+    /**
+     * Preserve the skin tone of the target image
+     * @default true
+     */
+    preserveSkinTone?: boolean;
+}
+
+export interface FaceSwapRequest {
+    /**
+     * The target image where the face will be swapped TO.
+     * Can be a Base64 string or a remote URL.
+     */
+    targetImage: string;
+
+    /**
+     * The source image containing the face to swap FROM.
+     * Can be a Base64 string or a remote URL.
+     */
+    sourceImage: string;
+
+    /**
+     * Optional configuration for the swap process
+     */
+    options?: FaceSwapConfig;
+}
+
+export interface FaceSwapResult {
+    /**
+     * URL or Base64 of the resulting image
+     */
+    imageUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

package/src/features/face-swap/index.ts

@@ -0,0 +1,2 @@
+export * from './domain/entities';
+export * from './presentation/hooks';

package/src/features/face-swap/presentation/hooks.ts

@@ -0,0 +1,41 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useState, useCallback } from 'react';
+import { useGeneration } from '../../../presentation/hooks/use-generation';
+import { FaceSwapRequest, FaceSwapResult } from '../domain/entities';
+
+export interface UseFaceSwapReturn {
+    swapFace: (request: FaceSwapRequest) => Promise<FaceSwapResult>;
+    isSwapping: boolean;
+    result: FaceSwapResult | null;
+    error: Error | null;
+}
+
+export const useFaceSwap = (): UseFaceSwapReturn => {
+    // @ts-ignore - Deprecated feature, kept for backward compatibility
+    const { generate, isGenerating, error, result: genResult } = useGeneration<FaceSwapResult>({ model: 'face-swap' });
+    const [result, setResult] = useState<FaceSwapResult | null>(null);
+
+    const swapFace = useCallback(async (request: FaceSwapRequest) => {
+        // @ts-ignore - Deprecated feature
+        await generate(request);
+
+        if (genResult?.data) {
+            setResult(genResult.data as FaceSwapResult);
+            return genResult.data as FaceSwapResult;
+        }
+
+        throw new Error('Face swap failed to return a result');
+    }, [generate, genResult]);
+
+    return {
+        swapFace,
+        isSwapping: isGenerating,
+        result,
+        error: error as any,
+    };
+};

package/src/features/future-prediction/domain/entities.ts

@@ -0,0 +1,45 @@
+/**
+ * Future Prediction Domain Entities
+ */
+
+export interface FuturePredictionConfig {
+    /**
+     * Target age or years to add
+     */
+    targetAge?: number;
+
+    /**
+     * Years to add to current age
+     */
+    yearsToAdd?: number;
+
+    /**
+     * Gender (optional, if automatic detection fails)
+     */
+    gender?: 'male' | 'female';
+}
+
+export interface FuturePredictionRequest {
+    /**
+     * The image to process.
+     * Can be a Base64 string or a remote URL.
+     */
+    image: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: FuturePredictionConfig;
+}
+
+export interface FuturePredictionResult {
+    /**
+     * The processed image URL or Base64
+     */
+    imageUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

package/src/features/future-prediction/index.ts

@@ -0,0 +1,2 @@
+export * from './domain/entities';
+export * from './presentation/hooks';

package/src/features/future-prediction/presentation/hooks.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useState, useCallback } from 'react';
+import { useGeneration } from '../../../presentation/hooks/use-generation';
+import { FuturePredictionRequest, FuturePredictionResult } from '../domain/entities';
+
+export interface UseFuturePredictionReturn {
+    predictFuture: (request: FuturePredictionRequest) => Promise<FuturePredictionResult>;
+    isPredicting: boolean;
+    result: FuturePredictionResult | null;
+    error: Error | null;
+}
+
+export const useFuturePrediction = (): UseFuturePredictionReturn => {
+    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
+    const [result, setResult] = useState<FuturePredictionResult | null>(null);
+
+    const predictFuture = useCallback(async (request: FuturePredictionRequest) => {
+        await generate(request as any);
+
+        if (genResult?.data) {
+            setResult(genResult.data as FuturePredictionResult);
+            return genResult.data as FuturePredictionResult;
+        }
+
+        throw new Error('Future prediction failed to return a result');
+    }, [generate, genResult]);
+
+    return {
+        predictFuture,
+        isPredicting: isGenerating,
+        result,
+        error: error as any,
+    };
+};

package/src/features/image-captioning/domain/entities.ts

@@ -0,0 +1,47 @@
+/**
+ * Image Captioning Domain Entities
+ */
+
+export interface ImageCaptioningConfig {
+    /**
+     * Detail level of the caption
+     * @default 'standard'
+     */
+    detailLevel?: 'brief' | 'standard' | 'detailed';
+
+    /**
+     * Language for the caption
+     * @default 'en'
+     */
+    language?: string;
+}
+
+export interface ImageCaptioningRequest {
+    /**
+     * The image to be captioned.
+     * Can be a Base64 string or a remote URL.
+     */
+    image: string;
+
+    /**
+     * Optional context or question to guide the captioning
+     */
+    prompt?: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: ImageCaptioningConfig;
+}
+
+export interface ImageCaptioningResult {
+    /**
+     * The generated caption text
+     */
+    text: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

package/src/features/image-captioning/index.ts

@@ -0,0 +1,2 @@
+export * from './domain/entities';
+export * from './presentation/hooks';

package/src/features/image-captioning/presentation/hooks.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useState, useCallback } from 'react';
+import { useGeneration } from '../../../presentation/hooks/use-generation';
+import { ImageCaptioningRequest, ImageCaptioningResult } from '../domain/entities';
+
+export interface UseImageCaptioningReturn {
+    generateCaption: (request: ImageCaptioningRequest) => Promise<ImageCaptioningResult>;
+    isGenerating: boolean;
+    result: ImageCaptioningResult | null;
+    error: Error | null;
+}
+
+export const useImageCaptioning = (): UseImageCaptioningReturn => {
+    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
+    const [result, setResult] = useState<ImageCaptioningResult | null>(null);
+
+    const generateCaption = useCallback(async (request: ImageCaptioningRequest) => {
+        await generate(request as any);
+
+        if (genResult?.data) {
+            setResult(genResult.data as ImageCaptioningResult);
+            return genResult.data as ImageCaptioningResult;
+        }
+
+        throw new Error('Caption generation failed to return a result');
+    }, [generate, genResult]);
+
+    return {
+        generateCaption,
+        isGenerating,
+        result,
+        error: error as any,
+    };
+};

package/src/features/inpainting/domain/entities.ts

@@ -0,0 +1,58 @@
+/**
+ * Inpainting Domain Entities
+ */
+
+export interface InpaintingConfig {
+    /**
+     * Strength of the inpainting effect (0.0 to 1.0)
+     * @default 0.75
+     */
+    strength?: number;
+
+    /**
+     * Guidance scale for prompt adherence
+     * @default 7.5
+     */
+    guidanceScale?: number;
+}
+
+export interface InpaintingRequest {
+    /**
+     * The original image.
+     * Can be a Base64 string or a remote URL.
+     */
+    image: string;
+
+    /**
+     * The mask image indicating areas to inpaint (white) vs keep (black).
+     * Can be a Base64 string or a remote URL.
+     */
+    mask: string;
+
+    /**
+     * Description of what to fill in the masked area
+     */
+    prompt: string;
+
+    /**
+     * Negative prompt for what to avoid
+     */
+    negativePrompt?: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: InpaintingConfig;
+}
+
+export interface InpaintingResult {
+    /**
+     * The resulting image with inpainting applied
+     */
+    imageUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

package/src/features/inpainting/index.ts

@@ -0,0 +1,2 @@
+export * from './domain/entities';
+export * from './presentation/hooks';

package/src/features/inpainting/presentation/hooks.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useState, useCallback } from 'react';
+import { useGeneration } from '../../../presentation/hooks/use-generation';
+import { InpaintingRequest, InpaintingResult } from '../domain/entities';
+
+export interface UseInpaintingReturn {
+    inpaint: (request: InpaintingRequest) => Promise<InpaintingResult>;
+    isInpainting: boolean;
+    result: InpaintingResult | null;
+    error: Error | null;
+}
+
+export const useInpainting = (): UseInpaintingReturn => {
+    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
+    const [result, setResult] = useState<InpaintingResult | null>(null);
+
+    const inpaint = useCallback(async (request: InpaintingRequest) => {
+        await generate(request as any);
+
+        if (genResult?.data) {
+            setResult(genResult.data as InpaintingResult);
+            return genResult.data as InpaintingResult;
+        }
+
+        throw new Error('Inpainting failed to return a result');
+    }, [generate, genResult]);
+
+    return {
+        inpaint,
+        isInpainting: isGenerating,
+        result,
+        error: error as any,
+    };
+};

package/src/features/photo-restoration/domain/entities.ts

@@ -0,0 +1,48 @@
+/**
+ * Photo Restoration Domain Entities
+ */
+
+export interface PhotoRestorationConfig {
+    /**
+     * Whether to fix scratches and creases
+     * @default true
+     */
+    fixScratches?: boolean;
+
+    /**
+     * Whether to enhance faces in the photo
+     * @default true
+     */
+    enhanceFaces?: boolean;
+
+    /**
+     * Upscale factor for the result
+     * @default 2
+     */
+    upscaleFactor?: 1 | 2 | 4;
+}
+
+export interface PhotoRestorationRequest {
+    /**
+     * The image to restore.
+     * Can be a Base64 string or a remote URL.
+     */
+    image: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: PhotoRestorationConfig;
+}
+
+export interface PhotoRestorationResult {
+    /**
+     * The restored image URL or Base64
+     */
+    imageUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

package/src/features/photo-restoration/index.ts

@@ -0,0 +1,2 @@
+export * from './domain/entities';
+export * from './presentation/hooks';

package/src/features/photo-restoration/presentation/hooks.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useState, useCallback } from 'react';
+import { useGeneration } from '../../../presentation/hooks/use-generation';
+import { PhotoRestorationRequest, PhotoRestorationResult } from '../domain/entities';
+
+export interface UsePhotoRestorationReturn {
+    restorePhoto: (request: PhotoRestorationRequest) => Promise<PhotoRestorationResult>;
+    isRestoring: boolean;
+    result: PhotoRestorationResult | null;
+    error: Error | null;
+}
+
+export const usePhotoRestoration = (): UsePhotoRestorationReturn => {
+    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
+    const [result, setResult] = useState<PhotoRestorationResult | null>(null);
+
+    const restorePhoto = useCallback(async (request: PhotoRestorationRequest) => {
+        await generate(request as any);
+
+        if (genResult?.data) {
+            setResult(genResult.data as PhotoRestorationResult);
+            return genResult.data as PhotoRestorationResult;
+        }
+
+        throw new Error('Photo restoration failed to return a result');
+    }, [generate, genResult]);
+
+    return {
+        restorePhoto,
+        isRestoring: isGenerating,
+        result,
+        error: error as any,
+    };
+};

package/src/features/sketch-to-image/domain/entities.ts

@@ -0,0 +1,47 @@
+/**
+ * Sketch to Image Domain Entities
+ */
+
+export interface SketchToImageConfig {
+    /**
+     * Strength of the prompt influence vs sketch influence (0.0 to 1.0)
+     * @default 0.7
+     */
+    strength?: number;
+
+    /**
+     * Steps for generation
+     * @default 20
+     */
+    steps?: number;
+}
+
+export interface SketchToImageRequest {
+    /**
+     * The sketch image.
+     * Can be a Base64 string or a remote URL.
+     */
+    sketchImage: string;
+
+    /**
+     * Description of the desired output
+     */
+    prompt: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: SketchToImageConfig;
+}
+
+export interface SketchToImageResult {
+    /**
+     * The generated realistic image URL
+     */
+    imageUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

package/src/features/sketch-to-image/index.ts

@@ -0,0 +1,2 @@
+export * from './domain/entities';
+export * from './presentation/hooks';

package/src/features/sketch-to-image/presentation/hooks.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useState, useCallback } from 'react';
+import { useGeneration } from '../../../presentation/hooks/use-generation';
+import { SketchToImageRequest, SketchToImageResult } from '../domain/entities';
+
+export interface UseSketchToImageReturn {
+    generateFromSketch: (request: SketchToImageRequest) => Promise<SketchToImageResult>;
+    isGenerating: boolean;
+    result: SketchToImageResult | null;
+    error: Error | null;
+}
+
+export const useSketchToImage = (): UseSketchToImageReturn => {
+    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
+    const [result, setResult] = useState<SketchToImageResult | null>(null);
+
+    const generateFromSketch = useCallback(async (request: SketchToImageRequest) => {
+        await generate(request as any);
+
+        if (genResult?.data) {
+            setResult(genResult.data as SketchToImageResult);
+            return genResult.data as SketchToImageResult;
+        }
+
+        throw new Error('Sketch to image generation failed to return a result');
+    }, [generate, genResult]);
+
+    return {
+        generateFromSketch,
+        isGenerating,
+        result,
+        error: error as any,
+    };
+};

package/src/features/style-transfer/domain/entities.ts

@@ -0,0 +1,52 @@
+/**
+ * Style Transfer Domain Entities
+ */
+
+export interface StyleTransferConfig {
+    /**
+     * Strength of the style application (0.0 to 1.0)
+     * @default 1.0
+     */
+    strength?: number;
+
+    /**
+     * Preserve original colors
+     * @default false
+     */
+    preserveColor?: boolean;
+}
+
+export interface StyleTransferRequest {
+    /**
+     * The content image to apply style TO.
+     * Can be a Base64 string or a remote URL.
+     */
+    contentImage: string;
+
+    /**
+     * The style image references (Base64 or URL)
+     */
+    styleImage?: string;
+
+    /**
+     * Or a preset style ID (e.g. "van_gogh_starry_night")
+     */
+    stylePreset?: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: StyleTransferConfig;
+}
+
+export interface StyleTransferResult {
+    /**
+     * The stylized image URL or Base64
+     */
+    imageUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

package/src/features/style-transfer/index.ts

@@ -0,0 +1,2 @@
+export * from './domain/entities';
+export * from './presentation/hooks';

package/src/features/style-transfer/presentation/hooks.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useState, useCallback } from 'react';
+import { useGeneration } from '../../../presentation/hooks/use-generation';
+import { StyleTransferRequest, StyleTransferResult } from '../domain/entities';
+
+export interface UseStyleTransferReturn {
+    transferStyle: (request: StyleTransferRequest) => Promise<StyleTransferResult>;
+    isTransferring: boolean;
+    result: StyleTransferResult | null;
+    error: Error | null;
+}
+
+export const useStyleTransfer = (): UseStyleTransferReturn => {
+    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
+    const [result, setResult] = useState<StyleTransferResult | null>(null);
+
+    const transferStyle = useCallback(async (request: StyleTransferRequest) => {
+        await generate(request as any);
+
+        if (genResult?.data) {
+            setResult(genResult.data as StyleTransferResult);
+            return genResult.data as StyleTransferResult;
+        }
+
+        throw new Error('Style transfer failed to return a result');
+    }, [generate, genResult]);
+
+    return {
+        transferStyle,
+        isTransferring: isGenerating,
+        result,
+        error: error as any,
+    };
+};

package/src/features/text-to-image/domain/entities.ts

@@ -0,0 +1,58 @@
+/**
+ * Text-to-Image Domain Entities
+ */
+
+export interface TextToImageConfig {
+    /**
+     * Width of the generated image
+     * @default 1024
+     */
+    width?: number;
+
+    /**
+     * Height of the generated image
+     * @default 1024
+     */
+    height?: number;
+
+    /**
+     * Number of inference steps
+     * @default 30
+     */
+    steps?: number;
+
+    /**
+     * Guidance scale
+     * @default 7.5
+     */
+    guidanceScale?: number;
+}
+
+export interface TextToImageRequest {
+    /**
+     * The description of the image to generate
+     */
+    prompt: string;
+
+    /**
+     * Negative prompt for what to avoid
+     */
+    negativePrompt?: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: TextToImageConfig;
+}
+
+export interface TextToImageResult {
+    /**
+     * The generated image URL or Base64
+     */
+    imageUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

package/src/features/text-to-image/index.ts

@@ -0,0 +1,2 @@
+export * from './domain/entities';
+export * from './presentation/hooks';

package/src/features/text-to-image/presentation/hooks.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useState, useCallback } from 'react';
+import { useGeneration } from '../../../presentation/hooks/use-generation';
+import { TextToImageRequest, TextToImageResult } from '../domain/entities';
+
+export interface UseTextToImageReturn {
+    generateImage: (request: TextToImageRequest) => Promise<TextToImageResult>;
+    isGenerating: boolean;
+    result: TextToImageResult | null;
+    error: Error | null;
+}
+
+export const useTextToImage = (): UseTextToImageReturn => {
+    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
+    const [result, setResult] = useState<TextToImageResult | null>(null);
+
+    const generateImage = useCallback(async (request: TextToImageRequest) => {
+        await generate(request as any);
+
+        if (genResult?.data) {
+            setResult(genResult.data as TextToImageResult);
+            return genResult.data as TextToImageResult;
+        }
+
+        throw new Error('Image generation failed to return a result');
+    }, [generate, genResult]);
+
+    return {
+        generateImage,
+        isGenerating,
+        result,
+        error: error as any,
+    };
+};

package/src/features/text-to-video/domain/entities.ts

@@ -0,0 +1,52 @@
+/**
+ * Text to Video Domain Entities
+ */
+
+export interface TextToVideoConfig {
+    /**
+     * Duration of the video in seconds
+     * @default 4
+     */
+    duration?: number;
+
+    /**
+     * FPS of the generated video
+     * @default 24
+     */
+    fps?: number;
+
+    /**
+     * Guidance scale
+     * @default 7.5
+     */
+    guidanceScale?: number;
+}
+
+export interface TextToVideoRequest {
+    /**
+     * The text prompt to generate video from
+     */
+    prompt: string;
+
+    /**
+     * Negative prompt
+     */
+    negativePrompt?: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: TextToVideoConfig;
+}
+
+export interface TextToVideoResult {
+    /**
+     * The generated video URL
+     */
+    videoUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

package/src/features/text-to-video/index.ts

@@ -0,0 +1,2 @@
+export * from './domain/entities';
+export * from './presentation/hooks';

package/src/features/text-to-video/presentation/hooks.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useState, useCallback } from 'react';
+import { useGeneration } from '../../../presentation/hooks/use-generation';
+import { TextToVideoRequest, TextToVideoResult } from '../domain/entities';
+
+export interface UseTextToVideoReturn {
+    generateVideo: (request: TextToVideoRequest) => Promise<TextToVideoResult>;
+    isGenerating: boolean;
+    result: TextToVideoResult | null;
+    error: Error | null;
+}
+
+export const useTextToVideo = (): UseTextToVideoReturn => {
+    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
+    const [result, setResult] = useState<TextToVideoResult | null>(null);
+
+    const generateVideo = useCallback(async (request: TextToVideoRequest) => {
+        await generate(request as any);
+
+        if (genResult?.data) {
+            setResult(genResult.data as TextToVideoResult);
+            return genResult.data as TextToVideoResult;
+        }
+
+        throw new Error('Video generation failed to return a result');
+    }, [generate, genResult]);
+
+    return {
+        generateVideo,
+        isGenerating,
+        result,
+        error: error as any,
+    };
+};

package/src/features/upscaling/domain/entities.ts

@@ -0,0 +1,42 @@
+/**
+ * Upscaling Domain Entities
+ */
+
+export interface UpscaleConfig {
+    /**
+     * The factor to upscale the image by
+     * @default 2
+     */
+    scaleFactor?: 2 | 4;
+
+    /**
+     * Whether to enhance faces during upscaling
+     * @default false
+     */
+    enhanceFaces?: boolean;
+}
+
+export interface UpscaleRequest {
+    /**
+     * The image to upscale.
+     * Can be a Base64 string or a remote URL.
+     */
+    image: string;
+
+    /**
+     * Optional configuration
+     */
+    options?: UpscaleConfig;
+}
+
+export interface UpscaleResult {
+    /**
+     * The upscaled image URL or Base64
+     */
+    imageUrl: string;
+
+    /**
+     * Metadata about the generation
+     */
+    metadata?: Record<string, unknown>;
+}

package/src/features/upscaling/index.ts

@@ -0,0 +1,2 @@
+export * from './domain/entities';
+export * from './presentation/hooks';

package/src/features/upscaling/presentation/hooks.ts

@@ -0,0 +1,39 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useState, useCallback } from 'react';
+import { useGeneration } from '../../../presentation/hooks/use-generation';
+import { UpscaleRequest, UpscaleResult } from '../domain/entities';
+
+export interface UseUpscalingReturn {
+    upscale: (request: UpscaleRequest) => Promise<UpscaleResult>;
+    isUpscaling: boolean;
+    result: UpscaleResult | null;
+    error: Error | null;
+}
+
+export const useUpscaling = (): UseUpscalingReturn => {
+    const { generate, isGenerating, error, result: genResult } = useGeneration({ model: "deprecated" });
+    const [result, setResult] = useState<UpscaleResult | null>(null);
+
+    const upscale = useCallback(async (request: UpscaleRequest) => {
+        await generate(request as any);
+
+        if (genResult?.data) {
+            setResult(genResult.data as UpscaleResult);
+            return genResult.data as UpscaleResult;
+        }
+
+        throw new Error('Upscaling failed to return a result');
+    }, [generate, genResult]);
+
+    return {
+        upscale,
+        isUpscaling: isGenerating,
+        result,
+        error: error as any,
+    };
+};

package/src/index.ts

@@ -245,4 +245,6 @@ export * from "./domains/face-detection";
 // DOMAINS - Feature Background
 // =============================================================================
 
-export * from "./domains/feature-background";
+export * from "./features/background";
+
+

package/src/presentation/hooks/photo-generation.types.ts

@@ -20,6 +20,14 @@ export interface PhotoGenerationError {
   originalError?: Error;
 }
 
+export interface AlertMessages {
+  networkError: string;
+  policyViolation: string;
+  saveFailed: string;
+  creditFailed: string;
+  unknown: string;
+}
+
 export interface PhotoGenerationConfig<TInput, TResult, TSaveInput> {
   generate: (input: TInput) => Promise<TResult>;
   save?: (result: TResult, input: TInput) => Promise<TSaveInput>;
@@ -29,6 +37,7 @@ export interface PhotoGenerationConfig<TInput, TResult, TSaveInput> {
   onSuccess?: (result: TResult) => void;
   onError?: (error: PhotoGenerationError) => void;
   onSaveComplete?: (saveResult: TSaveInput) => void;
+  alertMessages: AlertMessages;
 }
 
 export interface PhotoGenerationState<TResult = unknown> {

package/src/presentation/hooks/usePhotoGeneration.ts

@@ -5,6 +5,7 @@
 
 import { useState, useCallback, useRef } from "react";
 import { useOfflineStore } from "@umituz/react-native-offline";
+import { useAlert } from "@umituz/react-native-design-system";
 import type {
   PhotoGenerationConfig,
   PhotoGenerationState,
@@ -29,6 +30,7 @@ export const usePhotoGeneration = <TInput, TResult, TSaveInput = unknown>(
     onSuccess,
     onError,
     onSaveComplete,
+    alertMessages,
   } = config;
 
   const [state, setState] = useState<PhotoGenerationState<TResult>>({
@@ -41,6 +43,7 @@ export const usePhotoGeneration = <TInput, TResult, TSaveInput = unknown>(
   const [status, setStatus] = useState<PhotoGenerationStatus>("idle");
   const isGeneratingRef = useRef(false);
   const offlineStore = useOfflineStore();
+  const { showError } = useAlert();
 
   const createError = useCallback(
     (
@@ -143,6 +146,15 @@ export const usePhotoGeneration = <TInput, TResult, TSaveInput = unknown>(
           progress: 0,
         });
         setStatus("error");
+
+        const errorMessage =
+          generationError.type === "network_error" ? alertMessages.networkError :
+          generationError.type === "policy_violation" ? alertMessages.policyViolation :
+          generationError.type === "save_failed" ? alertMessages.saveFailed :
+          generationError.type === "credit_failed" ? alertMessages.creditFailed :
+          alertMessages.unknown;
+
+        showError("Error", errorMessage);
         onError?.(generationError);
       } finally {
         isGeneratingRef.current = false;