@umituz/react-native-ai-generation-content 1.90.10 → 1.90.12

package/package.json

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

package/src/domains/background/infrastructure/services/job-poller.service.ts

@@ -81,13 +81,13 @@ export async function pollJob<T = unknown>(
     try {
       // Check job status
       const statusResult = await withAbortSignal(
-        provider.checkStatus(requestId, model),
+        provider.getJobStatus(model, requestId),
         signal,
         config.maxTotalTimeMs ? config.maxTotalTimeMs - (Date.now() - startTime) : undefined
       );
 
       // Notify status change
-      if (onStatusChange && typeof statusResult === 'object' && 'status' in statusResult) {
+      if (onStatusChange && statusResult && typeof statusResult === 'object' && 'status' in statusResult) {
         onStatusChange(statusResult as JobStatus);
       }
 
@@ -96,7 +96,7 @@ export async function pollJob<T = unknown>(
       if (statusError) {
         return {
           success: false,
-          error: statusError,
+          error: statusError instanceof Error ? statusError : new Error(String(statusError)),
           attempts: attempt + 1,
           elapsedMs: Date.now() - startTime,
         };
@@ -106,7 +106,7 @@ export async function pollJob<T = unknown>(
       consecutiveErrors = 0;
 
       // Check if job is complete
-      if (isJobComplete(statusResult as JobStatus | Record<string, unknown>)) {
+      if (isJobComplete(statusResult as JobStatus | string)) {
         // Validate result
         const validationResult = validateResult(statusResult);
         if (!validationResult.isValid) {

package/src/domains/content-moderation/infrastructure/services/moderators/image.moderator.ts

@@ -39,10 +39,10 @@ class ImageModerator extends BaseModerator {
     // Use shared URL validation
     const urlValidation = validateUrl(uri);
     if (!urlValidation.isValid) {
-      if (urlValidation.errors.required) {
+      if ('required' in urlValidation.errors) {
         return this.createViolation("empty-uri", "Image Validation", "empty URI");
       }
-      if (urlValidation.errors.pattern) {
+      if ('pattern' in urlValidation.errors) {
         return this.createViolation(
           "invalid-protocol",
           "Image Validation",
@@ -57,7 +57,7 @@ class ImageModerator extends BaseModerator {
     });
 
     if (!lengthValidation.isValid) {
-      if (lengthValidation.errors.maxLength) {
+      if ('maxLength' in lengthValidation.errors) {
         return this.createViolation(
           "uri-too-long",
           "Image Validation",

package/src/domains/content-moderation/infrastructure/services/moderators/text.moderator.ts

@@ -63,7 +63,7 @@ class TextModerator extends BaseModerator {
     });
 
     if (!stringValidation.isValid) {
-      if (stringValidation.errors.maxLength) {
+      if ('maxLength' in stringValidation.errors) {
         return this.createViolation("too-long", "Validation", "length exceeded");
       }
       return this.createViolation("empty-content", "Validation", "empty");

package/src/domains/content-moderation/infrastructure/services/moderators/video.moderator.ts

@@ -39,10 +39,10 @@ class VideoModerator extends BaseModerator {
     // Use shared URL validation
     const urlValidation = validateUrl(uri);
     if (!urlValidation.isValid) {
-      if (urlValidation.errors.required) {
+      if ('required' in urlValidation.errors) {
         return this.createViolation("empty-uri", "Video Validation", "empty URI");
       }
-      if (urlValidation.errors.pattern) {
+      if ('pattern' in urlValidation.errors) {
         return this.createViolation(
           "invalid-protocol",
           "Video Validation",
@@ -57,7 +57,7 @@ class VideoModerator extends BaseModerator {
     });
 
     if (!lengthValidation.isValid) {
-      if (lengthValidation.errors.maxLength) {
+      if ('maxLength' in lengthValidation.errors) {
         return this.createViolation(
           "uri-too-long",
           "Video Validation",

package/src/domains/content-moderation/infrastructure/services/moderators/voice.moderator.ts

@@ -40,7 +40,7 @@ class VoiceModerator extends BaseModerator {
     });
 
     if (!stringValidation.isValid) {
-      if (stringValidation.errors.maxLength) {
+      if ('maxLength' in stringValidation.errors) {
         return this.createViolation(
           "too-long",
           "Voice Validation",

package/src/domains/creations/domain/constants/creation-fields.constants.ts

@@ -53,7 +53,7 @@ export const CREATION_FIELDS = {
 } as const;
 
 /** Union type of all field names */
-type CreationFieldName =
+export type CreationFieldName =
   typeof CREATION_FIELDS[keyof typeof CREATION_FIELDS];
 
 /**

package/src/domains/creations/presentation/hooks/useCreationPersistence.ts

@@ -53,7 +53,8 @@ export function useCreationPersistence(
 
       const validation = runAllValidations(result.imageUrl, result.videoUrl);
       if (!validation.isValid) {
-        await markCreationAsFailed(repository, userId, result.creationId, validation.error!);
+        const firstError = Object.values(validation.errors)[0];
+        await markCreationAsFailed(repository, userId, result.creationId, firstError || "Validation failed");
         return;
       }
 

package/src/domains/creations/presentation/hooks/useProcessingJobsPoller.ts

@@ -4,8 +4,11 @@
  */
 
 import { useEffect } from 'react';
+import type { Creation } from '../../../../domain/entities/Creation';
 
 export interface UseProcessingJobsPollerConfig {
+  userId: string | null;
+  creations: Creation[];
   enabled?: boolean;
   interval?: number;
 }
@@ -16,24 +19,32 @@ export interface UseProcessingJobsPollerReturn {
 
 /**
  * Hook to poll processing jobs
- * TODO: Implement actual polling logic
  */
 export function useProcessingJobsPoller(
-  config: UseProcessingJobsPollerConfig = {}
+  config: UseProcessingJobsPollerConfig
 ): UseProcessingJobsPollerReturn {
-  const { enabled = false, interval = 5000 } = config;
+  const { userId, creations, enabled = false, interval = 5000 } = config;
 
   useEffect(() => {
-    if (!enabled) return;
+    if (!enabled || !userId) return;
 
     const timer = setInterval(() => {
-      // Polling logic here
+      // Polling logic here - check processing creations and update their status
+      const processingCreations = creations.filter(c => c.status === 'processing');
+      processingCreations.forEach(async (creation) => {
+        try {
+          // Check job status and update creation
+          // TODO: Implement actual polling logic
+        } catch (error) {
+          console.error('Error polling job status:', error);
+        }
+      });
     }, interval);
 
     return () => clearInterval(timer);
-  }, [enabled, interval]);
+  }, [enabled, interval, userId, creations]);
 
   return {
-    isPolling: enabled,
+    isPolling: enabled && !!userId,
   };
 }

package/src/domains/face-detection/domain/entities/FaceDetection.ts

@@ -13,6 +13,7 @@ export interface FaceDetectionResult {
 
 export interface FaceValidationState extends BaseFeatureState<FaceDetectionResult> {
   isValidating: boolean;
+  result?: FaceDetectionResult;
 }
 
 export interface FaceDetectionConfig {

package/src/domains/generation/infrastructure/couple-generation-builder/builder-couple-prompt.ts

@@ -49,7 +49,7 @@ export function processCouplePrompt(
 
   // 4. CREATE FINAL PROMPT - Photorealistic
   logBuilderStep(prefix, "STEP 4: CREATE PHOTOREALISTIC PROMPT", {
-    isCouple: isCoupleMode,
+    isCoupleMode,
     hasCustomInstructions: !!customInstructions
   });
 

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.strategy.ts

@@ -5,7 +5,8 @@
  */
 
 import type { WizardStrategy } from "./wizard-strategy.types";
-import type { CreateVideoStrategyOptions } from "./video-generation.types";
+import type { CreateVideoStrategyOptions, WizardVideoInput } from "./video-generation.types";
+import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
 import { validateWizardVideoInput } from "./video-generation.validation";
 import { executeVideoGeneration, submitVideoGenerationToQueue } from "./video-generation.executor";
 
@@ -48,3 +49,25 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
   };
 }
 
+/**
+ * Build video input from wizard data and scenario
+ */
+export async function buildVideoInput(
+  wizardData: Record<string, unknown>,
+  scenario: WizardScenarioData
+): Promise<WizardVideoInput> {
+  const prompt = (wizardData.prompt as string | undefined) || scenario.prompt || "";
+  const input: WizardVideoInput = {
+    prompt,
+    sourceImageBase64: wizardData.sourceImageBase64 as string | undefined,
+    targetImageBase64: wizardData.targetImageBase64 as string | undefined,
+    duration: wizardData.duration as number | undefined,
+    aspectRatio: wizardData.aspectRatio as string | undefined,
+    resolution: wizardData.resolution as string | undefined,
+    audioUrl: wizardData.audioUrl as string | undefined,
+    qualityMode: wizardData.qualityMode as "draft" | "normal" | undefined,
+  };
+
+  return input;
+}
+

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.types.ts

@@ -32,3 +32,17 @@ export interface CreateVideoStrategyOptions {
   /** Credit cost for this generation - REQUIRED, determined by the app */
   readonly creditCost: number;
 }
+
+export interface ExecutionResult {
+  success: boolean;
+  videoUrl?: string;
+  requestId?: string;
+  error?: string;
+}
+
+export interface SubmissionResult {
+  success: boolean;
+  requestId?: string;
+  model?: string;
+  error?: string;
+}

package/src/domains/generation/wizard/presentation/hooks/photo-upload/types.ts

@@ -2,10 +2,14 @@
  * Generic Photo Upload State Hook - Type Definitions
  */
 
-import type { UploadedImage } from "../../../../../presentation/hooks/generation/useAIGenerateState";
-
-// Re-export for use in this module
-export type { UploadedImage };
+export interface UploadedImage {
+  uri: string;
+  base64?: string;
+  width?: number;
+  height?: number;
+  previewUrl?: string;
+  fileSize?: number;
+}
 
 export interface PhotoUploadConfig {
   readonly maxFileSizeMB?: number;

package/src/domains/generation/wizard/presentation/hooks/photo-upload/usePhotoUploadStateLogic.ts

@@ -4,7 +4,7 @@
 
 import { useCallback, useRef, useEffect } from "react";
 import { useMedia, MediaQuality, MediaValidationError, MEDIA_CONSTANTS } from "@umituz/react-native-design-system/media";
-import type { UploadedImage } from "../../../../../presentation/hooks/generation/useAIGenerateState";
+import type { UploadedImage } from "./types";
 import type { PhotoUploadConfig, PhotoUploadError, PhotoUploadTranslations } from "./types";
 
 export function usePhotoUploadStateLogic(

package/src/domains/generation/wizard/presentation/hooks/video-queue/use-video-queue-utils.ts

@@ -109,15 +109,24 @@ export function extractInputMetadata(params: {
   readonly model: string;
   readonly prompt: string;
   readonly imageUrls?: string[];
+  readonly duration?: number;
+  readonly resolution?: string;
+  readonly aspectRatio?: string;
 }): {
   readonly model: string;
   readonly prompt: string;
   readonly imageUrls: string[];
+  readonly duration?: number;
+  readonly resolution?: string;
+  readonly aspectRatio?: string;
 } {
   return {
     model: params.model,
     prompt: params.prompt,
     imageUrls: params.imageUrls || [],
+    duration: params.duration,
+    resolution: params.resolution,
+    aspectRatio: params.aspectRatio,
   };
 }
 

package/src/domains/generation/wizard/presentation/hooks/video-queue/useVideoQueueGenerationStart.ts

@@ -39,7 +39,15 @@ export function useStartGeneration(
       let creationId: string | null = null;
       if (userId && prompt) {
         try {
-          const { duration, resolution, aspectRatio } = extractInputMetadata(input);
+          const inputRecord = input as Record<string, unknown>;
+          const { duration, resolution, aspectRatio } = extractInputMetadata({
+            model: scenario.model || "",
+            prompt,
+            imageUrls: (inputRecord.imageUrls || inputRecord.image_url) as string[] | undefined,
+            duration: inputRecord.duration as number | undefined,
+            resolution: inputRecord.resolution as string | undefined,
+            aspectRatio: inputRecord.aspectRatio as string | undefined,
+          });
 
           const result = await persistence.saveAsProcessing(userId, {
             scenarioId: scenario.id,

package/src/domains/image-to-video/domain/types/form.types.ts

@@ -11,6 +11,7 @@ export interface ImageToVideoFormState {
   animationStyle: AnimationStyleId;
   duration: VideoDuration;
   motionPrompt: string;
+  onError?: (error: string) => void;
 }
 
 export interface ImageToVideoFormActions {

package/src/domains/image-to-video/presentation/hooks/useImageToVideoFeature.ts

@@ -41,14 +41,14 @@ export function useImageToVideoFeature(props: UseImageToVideoFeatureProps): UseI
   const orchestrator = useGenerationOrchestrator(strategy, {
     userId,
     alertMessages: DEFAULT_ALERT_MESSAGES,
-    onSuccess: (result: unknown) => {
+    onSuccess: async (result: unknown) => {
       const typedResult = result as { success: boolean; videoUrl?: string; thumbnailUrl?: string };
       if (typedResult.success && typedResult.videoUrl) {
         config.onProcessingComplete?.(typedResult);
         callbacks?.onGenerate?.(typedResult);
       }
     },
-    onError: (err) => {
+    onError: async (err) => {
       config.onError?.(err.message);
       callbacks?.onError?.(err.message);
     },

package/src/domains/text-to-image/presentation/hooks/useGeneration.ts

@@ -72,7 +72,7 @@ export function useGeneration(options: UseGenerationOptions): UseGenerationRetur
   const { generate, isGenerating, error } = useGenerationOrchestrator(strategy, {
     userId: userId ?? undefined,
     alertMessages: DEFAULT_ALERT_MESSAGES,
-    onSuccess: (result) => {
+    onSuccess: async (result) => {
       const imageUrls = result as string[];
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[TextToImage] Success! Generated", imageUrls.length, "image(s)");
@@ -80,7 +80,7 @@ export function useGeneration(options: UseGenerationOptions): UseGenerationRetur
       callbacks.onSuccess?.(imageUrls);
       onPromptCleared?.();
     },
-    onError: (err) => {
+    onError: async (err) => {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[TextToImage] Error:", err.message);
       }

package/src/domains/text-to-video/presentation/hooks/useTextToVideoFeature.ts

@@ -71,8 +71,8 @@ export function useTextToVideoFeature(props: UseTextToVideoFeatureProps): UseTex
   const orchestrator = useGenerationOrchestrator(strategy, {
     userId,
     alertMessages: DEFAULT_ALERT_MESSAGES,
-    onSuccess: (result) => callbacks.onGenerate?.(result as TextToVideoResult),
-    onError: (err) => callbacks.onError?.(err.message),
+    onSuccess: async (result) => callbacks.onGenerate?.(result as TextToVideoResult),
+    onError: async (err) => callbacks.onError?.(err.message),
   });
 
   const setPrompt = useCallback((prompt: string) => {

package/src/infrastructure/services/image-feature-executor.service.ts

@@ -68,7 +68,7 @@ export async function executeImageFeature(
     if (!urlValidation.isValid) {
       return {
         success: false,
-        error: `Invalid image URL received: ${urlValidation.errors.join(", ")}`
+        error: `Invalid image URL received: ${Object.values(urlValidation.errors).join(", ")}`
       };
     }
 

package/src/infrastructure/services/multi-image-generation.executor.ts

@@ -100,10 +100,11 @@ export async function executeMultiImageGeneration(
           if (typeof imageUrl === "string" && imageUrl.length > 0) {
             const urlValidation = validateURL(imageUrl);
             if (!urlValidation.isValid) {
-              addGenerationLog(sid, TAG, `Invalid URL in response: ${urlValidation.errors.join(", ")}`, 'error');
+              const errorMsg = Object.values(urlValidation.errors).join(", ");
+              addGenerationLog(sid, TAG, `Invalid URL in response: ${errorMsg}`, 'error');
               return {
                 success: false,
-                error: `Invalid image URL received: ${urlValidation.errors.join(", ")}`,
+                error: `Invalid image URL received: ${errorMsg}`,
                 logSessionId: sid,
               };
             }

package/src/infrastructure/services/video-feature-executor.service.ts

@@ -54,7 +54,7 @@ export async function executeVideoFeature(
     if (!urlValidation.isValid) {
       return {
         success: false,
-        error: `Invalid video URL received: ${urlValidation.errors.join(", ")}`
+        error: `Invalid video URL received: ${Object.values(urlValidation.errors).join(", ")}`
       };
     }
 

package/src/infrastructure/validation/advanced-validator.ts

@@ -3,9 +3,8 @@
  * Complex validators for objects, arrays, and combined validations
  */
 
-import type { ValidationResult } from "./base-validator";
-import { validateString } from "./base-validator";
-import type { StringValidationOptions } from "./base-validator";
+import type { ValidationResult, StringValidationOptions } from "../../shared-kernel/infrastructure/validation";
+import { validateString } from "../../shared-kernel/infrastructure/validation";
 
 /**
  * Validates object structure
@@ -14,19 +13,19 @@ export function validateObject(
   input: unknown,
   requiredFields: readonly string[] = []
 ): ValidationResult {
-  const errors: string[] = [];
+  const errors: Record<string, string> = {};
 
   if (typeof input !== "object" || input === null) {
-    return { isValid: false, errors: ["Input must be an object"] };
+    return { isValid: false, errors: { input: "Input must be an object" } };
   }
 
   for (const field of requiredFields) {
     if (!(field in input)) {
-      errors.push(`Missing required field: ${field}`);
+      errors[field] = `Missing required field: ${field}`;
     }
   }
 
-  return { isValid: errors.length === 0, errors };
+  return { isValid: Object.keys(errors).length === 0, errors };
 }
 
 /**
@@ -40,18 +39,18 @@ export function validateArray(
     readonly itemType?: "string" | "number" | "object";
   } = {}
 ): ValidationResult {
-  const errors: string[] = [];
+  const errors: Record<string, string> = {};
 
   if (!Array.isArray(input)) {
-    return { isValid: false, errors: ["Input must be an array"] };
+    return { isValid: false, errors: { input: "Input must be an array" } };
   }
 
   if (options.minLength !== undefined && input.length < options.minLength) {
-    errors.push(`Array must have at least ${options.minLength} items`);
+    errors.minLength = `Array must have at least ${options.minLength} items`;
   }
 
   if (options.maxLength !== undefined && input.length > options.maxLength) {
-    errors.push(`Array must have at most ${options.maxLength} items`);
+    errors.maxLength = `Array must have at most ${options.maxLength} items`;
   }
 
   if (options.itemType) {
@@ -65,22 +64,28 @@ export function validateArray(
           : typeof item === "object" && item !== null;
 
       if (!isValidType) {
-        errors.push(`Item at index ${i} is not a ${options.itemType}`);
+        errors[`item_${i}`] = `Item at index ${i} is not a ${options.itemType}`;
       }
     }
   }
 
-  return { isValid: errors.length === 0, errors };
+  return { isValid: Object.keys(errors).length === 0, errors };
 }
 
 /**
  * Combines multiple validation results
  */
 export function combineValidationResults(
-  results: readonly ValidationResult[]
+  ...results: ValidationResult[]
 ): ValidationResult {
-  const allErrors = results.flatMap((r) => r.errors);
-  return { isValid: allErrors.length === 0, errors: allErrors };
+  const allErrors = results.reduce((acc, result) => {
+    return { ...acc, ...result.errors };
+  }, {} as Record<string, string>);
+
+  return {
+    isValid: Object.keys(allErrors).length === 0,
+    errors: allErrors,
+  };
 }
 
 /**

package/src/infrastructure/validation/ai-validator.ts

@@ -26,7 +26,7 @@ export function validateAIPrompt(input: unknown): ValidationResult {
  */
 export function validateImageData(input: unknown): ValidationResult {
   if (typeof input !== "string") {
-    return { isValid: false, errors: ["Image data must be a string"] };
+    return { isValid: false, errors: { type: "Image data must be a string" } };
   }
 
   const trimmed = input.trim();
@@ -40,11 +40,11 @@ export function validateImageData(input: unknown): ValidationResult {
   if (trimmed.startsWith("data:image/")) {
     const parts = trimmed.split(",");
     if (parts.length !== 2) {
-      return { isValid: false, errors: ["Invalid data URI format"] };
+      return { isValid: false, errors: { format: "Invalid data URI format" } };
     }
     const base64Part = parts[1];
     if (!base64Part || base64Part.length === 0) {
-      return { isValid: false, errors: ["Invalid data URI: missing base64 data"] };
+      return { isValid: false, errors: { data: "Invalid data URI: missing base64 data" } };
     }
     return validateBase64(base64Part);
   }
@@ -57,7 +57,7 @@ export function validateImageData(input: unknown): ValidationResult {
 
   return {
     isValid: false,
-    errors: ["Image data must be a URL, base64 data URI, or valid base64 string"],
+    errors: { format: "Image data must be a URL, base64 data URI, or valid base64 string" },
   };
 }
 

package/src/infrastructure/validation/base-validator.ts

@@ -3,89 +3,31 @@
  * Core validation functions for strings, numbers, URLs, emails, and base64
  */
 
-import type { ValidationResult, StringValidationOptions, NumericValidationOptions } from "./base-validator.types";
+import type { ValidationResult, StringValidationOptions, NumberValidationOptions } from "../../shared-kernel/infrastructure/validation";
+import { validateString, validateNumber } from "../../shared-kernel/infrastructure/validation";
 
 // Re-export types for convenience
-export type { ValidationResult, StringValidationOptions, NumericValidationOptions };
+export type { ValidationResult, StringValidationOptions, NumberValidationOptions } from "../../shared-kernel/infrastructure/validation";
 
-/**
- * Validates a string input against provided rules
- */
-export function validateString(
-  input: unknown,
-  options: StringValidationOptions = {}
-): ValidationResult {
-  const errors: string[] = [];
-
-  if (typeof input !== "string") {
-    return { isValid: false, errors: ["Input must be a string"] };
-  }
-
-  const value = options.trim !== false ? input.trim() : input;
-
-  if (options.minLength !== undefined && value.length < options.minLength) {
-    errors.push(`Input must be at least ${options.minLength} characters`);
-  }
-
-  if (options.maxLength !== undefined && value.length > options.maxLength) {
-    errors.push(`Input must be at most ${options.maxLength} characters`);
-  }
-
-  if (options.pattern && !options.pattern.test(value)) {
-    errors.push("Input format is invalid");
-  }
-
-  if (options.allowedCharacters && !options.allowedCharacters.test(value)) {
-    errors.push("Input contains invalid characters");
-  }
-
-  return { isValid: errors.length === 0, errors };
-}
-
-/**
- * Validates a numeric input
- */
-export function validateNumber(
-  input: unknown,
-  options: NumericValidationOptions = {}
-): ValidationResult {
-  const errors: string[] = [];
-
-  if (typeof input !== "number" || isNaN(input)) {
-    return { isValid: false, errors: ["Input must be a number"] };
-  }
-
-  if (options.integer && !Number.isInteger(input)) {
-    errors.push("Input must be an integer");
-  }
-
-  if (options.min !== undefined && input < options.min) {
-    errors.push(`Input must be at least ${options.min}`);
-  }
-
-  if (options.max !== undefined && input > options.max) {
-    errors.push(`Input must be at most ${options.max}`);
-  }
-
-  return { isValid: errors.length === 0, errors };
-}
+// Re-export validation functions for convenience
+export { validateString, validateNumber };
 
 /**
  * Validates URL format
  */
 export function validateURL(input: unknown): ValidationResult {
   if (typeof input !== "string") {
-    return { isValid: false, errors: ["URL must be a string"] };
+    return { isValid: false, errors: { type: "URL must be a string" } };
   }
 
   try {
     const url = new URL(input) as URL & { protocol: string };
     if (!["http:", "https:"].includes(url.protocol)) {
-      return { isValid: false, errors: ["Only HTTP and HTTPS protocols are allowed"] };
+      return { isValid: false, errors: { protocol: "Only HTTP and HTTPS protocols are allowed" } };
     }
-    return { isValid: true, errors: [] };
+    return { isValid: true, errors: {} };
   } catch {
-    return { isValid: false, errors: ["Invalid URL format"] };
+    return { isValid: false, errors: { format: "Invalid URL format" } };
   }
 }
 
@@ -94,15 +36,15 @@ export function validateURL(input: unknown): ValidationResult {
  */
 export function validateEmail(input: unknown): ValidationResult {
   if (typeof input !== "string") {
-    return { isValid: false, errors: ["Email must be a string"] };
+    return { isValid: false, errors: { type: "Email must be a string" } };
   }
 
   const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
   if (!emailRegex.test(input)) {
-    return { isValid: false, errors: ["Invalid email format"] };
+    return { isValid: false, errors: { format: "Invalid email format" } };
   }
 
-  return { isValid: true, errors: [] };
+  return { isValid: true, errors: {} };
 }
 
 /**
@@ -110,21 +52,21 @@ export function validateEmail(input: unknown): ValidationResult {
  */
 export function validateBase64(input: unknown): ValidationResult {
   if (typeof input !== "string") {
-    return { isValid: false, errors: ["Input must be a string"] };
+    return { isValid: false, errors: { type: "Input must be a string" } };
   }
 
   if (input.length === 0) {
-    return { isValid: false, errors: ["Base64 string cannot be empty"] };
+    return { isValid: false, errors: { length: "Base64 string cannot be empty" } };
   }
 
   const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
   if (!base64Regex.test(input)) {
-    return { isValid: false, errors: ["Invalid base64 format"] };
+    return { isValid: false, errors: { format: "Invalid base64 format" } };
   }
 
   if (input.length % 4 !== 0) {
-    return { isValid: false, errors: ["Base64 string length must be a multiple of 4"] };
+    return { isValid: false, errors: { length: "Base64 string length must be a multiple of 4" } };
   }
 
-  return { isValid: true, errors: [] };
+  return { isValid: true, errors: {} };
 }

package/src/infrastructure/validation/entity-validator.ts

@@ -14,7 +14,7 @@ export function validateUserId(input: unknown): ValidationResult {
     maxLength: 100,
     pattern: /^[a-zA-Z0-9_-]+$/,
   };
-  return validateString(input, options);
+  return validateString(typeof input === "string" ? input : String(input), options);
 }
 
 /**
@@ -25,6 +25,6 @@ export function validateCreationId(input: unknown): ValidationResult {
     minLength: 1,
     maxLength: 100,
   };
-  return validateString(input, options);
+  return validateString(typeof input === "string" ? input : String(input), options);
 }
 

package/src/infrastructure/validation/input-validator.ts

@@ -12,7 +12,7 @@ export {
   validateBase64,
   type ValidationResult,
   type StringValidationOptions,
-  type NumericValidationOptions,
+  type NumberValidationOptions,
 } from "./base-validator";
 
 // Sanitizers

package/src/presentation/hooks/generation/useImageGeneration.ts

@@ -88,7 +88,7 @@ export const useImageGeneration = <TInput extends ImageGenerationInput, TResult>
   return useGenerationOrchestrator(strategy, {
     userId,
     alertMessages,
-    onSuccess: onSuccess ? async (result) => onSuccess(result) : undefined,
+    onSuccess: onSuccess ? async (result) => onSuccess(result as TResult) : undefined,
     onError: async (error) => handleError(error),
   });
 };

package/src/presentation/hooks/generation/useVideoGeneration.ts

@@ -103,7 +103,7 @@ export const useVideoGeneration = <TResult>(
   return useGenerationOrchestrator(strategy, {
     userId,
     alertMessages,
-    onSuccess: onSuccess ? async (result) => onSuccess(result) : undefined,
+    onSuccess: onSuccess ? async (result) => onSuccess(result as TResult) : undefined,
     onError: async (error) => handleError(error),
   });
 };

package/src/shared-kernel/infrastructure/validation/index.ts

@@ -2,18 +2,9 @@
  * Shared Validation Utilities
  */
 
-import type {
-  ValidationResult,
-  StringValidationOptions,
-  NumericValidationOptions,
-} from "../../../infrastructure/validation/base-validator.types";
-
-// Re-export types
-export type {
-  ValidationResult,
-  StringValidationOptions,
-  NumericValidationOptions,
-};
+// Export all from common-validators
+export * from "./common-validators";
+export * from "./common-validators.types";
 
 // Export functions from advanced-validator
 export { combineValidationResults } from "../../../infrastructure/validation/advanced-validator";
@@ -22,37 +13,6 @@ export { combineValidationResults } from "../../../infrastructure/validation/adv
 export { handleError } from "./error-handler";
 export { ErrorType } from "./error-handler.types";
 
-/**
- * Validate a string is not empty
- */
-export function validateString(value: string): ValidationResult {
-  if (typeof value !== 'string') {
-    return { isValid: false, errors: ['Value must be a string'] };
-  }
-
-  if (value.trim().length === 0) {
-    return { isValid: false, errors: ['String cannot be empty'] };
-  }
-
-  return { isValid: true, errors: [] };
-}
-
-/**
- * Validate URL format
- */
-export function validateUrl(url: string): ValidationResult {
-  if (typeof url !== 'string') {
-    return { isValid: false, errors: ['URL must be a string'] };
-  }
-
-  try {
-    new URL(url);
-    return { isValid: true, errors: [] };
-  } catch {
-    return { isValid: false, errors: ['Invalid URL format'] };
-  }
-}
-
 /**
  * Validate required fields in an object
  */