@umituz/react-native-ai-generation-content 1.46.1 → 1.48.0

package/package.json

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

package/src/domains/generation/wizard/infrastructure/strategies/image-generation.executor.ts

@@ -28,11 +28,14 @@ function buildFinalPrompt(input: WizardImageInput, imageUrls: string[]): string
   const hasPhotos = imageUrls.length > 0;
 
   if (hasPhotos) {
+    // Custom prompt type means app provides complete prompt - skip identity preservation
+    const skipIdentityPreservation = input.promptType === "custom";
+
     return buildUnifiedPrompt({
       basePrompt: input.prompt,
       photoCount: imageUrls.length,
       interactionStyle: input.interactionStyle,
-      promptType: input.promptType,
+      skipIdentityPreservation,
     });
   }
 

package/src/domains/generation/wizard/infrastructure/strategies/shared/unified-prompt-builder.ts

@@ -5,12 +5,8 @@
  * Uses createPhotorealisticPrompt for text-only scenarios
  */
 
-import {
-  createMultiPersonPrompt,
-  createGeneticBlendPrompt,
-} from "../../../../../prompts/domain/entities/MultiPersonPromptStructure";
+import { createMultiPersonPrompt } from "../../../../../prompts/domain/entities/MultiPersonPromptStructure";
 import { createPhotorealisticPrompt } from "../../../../../prompts/domain/entities/BasePromptStructure";
-import type { ScenarioPromptType } from "../../../../../scenarios/domain/Scenario";
 
 export interface BuildPromptOptions {
   /** Base scenario prompt (aiPrompt from scenario config) */
@@ -19,18 +15,18 @@ export interface BuildPromptOptions {
   readonly photoCount: number;
   /** Interaction style from scenario (optional - only if scenario specifies it) */
   readonly interactionStyle?: string;
-  /** Prompt type - identity preservation or genetic blend */
-  readonly promptType?: ScenarioPromptType;
+  /** Skip identity preservation (for custom prompts like genetic blend) */
+  readonly skipIdentityPreservation?: boolean;
 }
 
 /**
  * Build unified prompt for any generation type
- * - Photo-based identity: Uses createMultiPersonPrompt with @image1, @image2 references
- * - Photo-based genetic_blend: Uses createGeneticBlendPrompt for child prediction
- * - Text-only: Uses createPhotorealisticPrompt with identity preservation
+ * - Photo-based: Uses createMultiPersonPrompt with @image1, @image2 references
+ * - Text-only: Uses createPhotorealisticPrompt
+ * - Custom: Uses basePrompt directly when skipIdentityPreservation is true
  */
 export function buildUnifiedPrompt(options: BuildPromptOptions): string {
-  const { basePrompt, photoCount, interactionStyle, promptType } = options;
+  const { basePrompt, photoCount, interactionStyle, skipIdentityPreservation } = options;
 
   // Text-only generation (no photos)
   if (photoCount === 0) {
@@ -41,9 +37,9 @@ export function buildUnifiedPrompt(options: BuildPromptOptions): string {
     });
   }
 
-  // Genetic blend for child prediction scenarios
-  if (promptType === "genetic_blend") {
-    return createGeneticBlendPrompt(basePrompt);
+  // Custom prompt handling (app provides complete prompt)
+  if (skipIdentityPreservation) {
+    return basePrompt;
   }
 
   // Default: Photo-based generation with identity preservation

package/src/domains/prompts/domain/entities/MultiPersonPromptStructure.ts

@@ -22,25 +22,6 @@ export const MULTI_PERSON_PRESERVATION_RULES: MultiPersonPreservationRules = {
   positioning: "Natural positioning, all looking at camera with natural expressions",
 };
 
-/**
- * Genetic blend rules for child prediction scenarios
- * Creates a new face by blending features from parent photos
- */
-export const GENETIC_BLEND_RULES = {
-  requirement: "Create a NEW child face by intelligently blending genetic features from both parents",
-  blendingRules: [
-    "Analyze facial features from @image1 (parent 1) and @image2 (parent 2)",
-    "Create a realistic genetic combination - mix eye shape, nose, lips, face structure",
-    "The child should look like a natural offspring of both parents",
-    "Use realistic child proportions appropriate for the specified age",
-  ],
-  forbidden: [
-    "Do NOT copy either parent's face directly",
-    "Do NOT create an adult face - maintain child proportions",
-    "Do NOT ignore either parent's features - blend from both",
-  ],
-};
-
 /**
  * Creates a multi-person prompt dynamically
  *
@@ -75,30 +56,3 @@ ${NATURAL_POSE_GUIDELINES}
 SCENARIO DESCRIPTION:
 ${scenarioPrompt}`;
 };
-
-/**
- * Creates a genetic blend prompt for child prediction scenarios
- * Instead of preserving identities, it blends parent features to create a child
- *
- * @param scenarioPrompt - The scenario description
- * @returns Complete prompt with genetic blending instructions
- */
-export const createGeneticBlendPrompt = (scenarioPrompt: string): string => {
-  return `GENETIC BLEND CHILD PREDICTION (HIGHEST PRIORITY):
-{
-  "policy": "CREATE NEW CHILD FACE FROM PARENT GENETICS",
-  "requirement": "${GENETIC_BLEND_RULES.requirement}",
-  "blending_rules": ${JSON.stringify(GENETIC_BLEND_RULES.blendingRules)},
-  "parent_references": {
-    "parent_1": "@image1 - extract genetic features (eye color, face shape, skin tone)",
-    "parent_2": "@image2 - extract genetic features (eye color, face shape, skin tone)"
-  },
-  "forbidden": ${JSON.stringify(GENETIC_BLEND_RULES.forbidden)},
-  "output": "A realistic child that is a natural genetic combination of both parents"
-}
-
-${PHOTOREALISTIC_RENDERING}
-
-SCENARIO DESCRIPTION:
-${scenarioPrompt}`;
-};

package/src/domains/prompts/domain/repositories/IAIPromptServices.ts

@@ -1,81 +1,10 @@
 import type { AIPromptTemplate } from '../entities/AIPromptTemplate';
 import type { AIPromptResult } from '../entities/types';
-import type { FaceSwapConfig } from '../entities/FaceSwapConfig';
-import type {
-  PhotoRestorationConfig
-} from '../entities/PhotoRestorationConfig';
-import type {
-  ImageEnhancementConfig,
-  EnhancementAdjustments
-} from '../entities/ImageEnhancementConfig';
-import type {
-  StyleTransferConfig
-} from '../entities/StyleTransferConfig';
-import type {
-  BackgroundRemovalConfig
-} from '../entities/BackgroundRemovalConfig';
-import type {
-  TextGenerationConfig
-} from '../entities/TextGenerationConfig';
-import type {
-  ColorizationConfig
-} from '../entities/ColorizationConfig';
-import type {
-  FuturePredictionConfig,
-  FuturePredictionResult,
-} from '../entities/FuturePredictionConfig';
-
-export interface IFaceSwapService {
-  generateTemplate(config: FaceSwapConfig): Promise<AIPromptResult<AIPromptTemplate>>;
-  generatePrompt(template: AIPromptTemplate, config: FaceSwapConfig): Promise<AIPromptResult<string>>;
-  validateConfig(config: FaceSwapConfig): boolean;
-  getAvailableStyles(): Promise<string[]>;
-}
-
-export interface IPhotoRestorationService {
-  generateTemplate(config: PhotoRestorationConfig): Promise<AIPromptResult<AIPromptTemplate>>;
-  generatePrompt(template: AIPromptTemplate, config: PhotoRestorationConfig): Promise<AIPromptResult<string>>;
-  validateConfig(config: PhotoRestorationConfig): boolean;
-  estimateQuality(config: PhotoRestorationConfig): number;
-}
-
-export interface IImageEnhancementService {
-  generateTemplate(config: ImageEnhancementConfig): Promise<AIPromptResult<AIPromptTemplate>>;
-  generatePrompt(template: AIPromptTemplate, config: ImageEnhancementConfig): Promise<AIPromptResult<string>>;
-  validateConfig(config: ImageEnhancementConfig): boolean;
-  calculateAdjustments(config: ImageEnhancementConfig): EnhancementAdjustments;
-}
-
-export interface IStyleTransferService {
-  generateTemplate(config: StyleTransferConfig): Promise<AIPromptResult<AIPromptTemplate>>;
-  generatePrompt(template: AIPromptTemplate, config: StyleTransferConfig): Promise<AIPromptResult<string>>;
-  validateConfig(config: StyleTransferConfig): boolean;
-  getAvailableStyles(): Promise<string[]>;
-}
-
-export interface IBackgroundRemovalService {
-  generateTemplate(config: BackgroundRemovalConfig): Promise<AIPromptResult<AIPromptTemplate>>;
-  generatePrompt(template: AIPromptTemplate, config: BackgroundRemovalConfig): Promise<AIPromptResult<string>>;
-  validateConfig(config: BackgroundRemovalConfig): boolean;
-  estimateProcessingTime(config: BackgroundRemovalConfig): number;
-}
-
-export interface ITextGenerationService {
-  generateTemplate(config: TextGenerationConfig): Promise<AIPromptResult<AIPromptTemplate>>;
-  generatePrompt(template: AIPromptTemplate, config: TextGenerationConfig): Promise<AIPromptResult<string>>;
-  validateConfig(config: TextGenerationConfig): boolean;
-  estimateTokens(config: TextGenerationConfig): number;
-  getGenerationParameters(config: TextGenerationConfig): Record<string, number>;
-}
-
-export interface IColorizationService {
-  generateTemplate(config: ColorizationConfig): Promise<AIPromptResult<AIPromptTemplate>>;
-  generatePrompt(template: AIPromptTemplate, config: ColorizationConfig): Promise<AIPromptResult<string>>;
-  validateConfig(config: ColorizationConfig): boolean;
-  getColorPalette(config: ColorizationConfig): string[];
-  getQualityScore(config: ColorizationConfig): number;
-}
 
+/**
+ * Prompt Generation Service Interface
+ * Core service for generating prompts from templates
+ */
 export interface IPromptGenerationService {
   generateFromTemplate(
     template: AIPromptTemplate,
@@ -90,11 +19,3 @@ export interface IPromptGenerationService {
     variables: Record<string, unknown>
   ): string;
 }
-
-export interface IFuturePredictionService {
-  generateTemplate(config: FuturePredictionConfig): Promise<AIPromptResult<AIPromptTemplate>>;
-  generatePrompts(config: FuturePredictionConfig): Promise<AIPromptResult<FuturePredictionResult>>;
-  validateConfig(config: FuturePredictionConfig): boolean;
-  buildImagePrompt(config: FuturePredictionConfig): string;
-  buildStoryPrompt(config: FuturePredictionConfig): string;
-}

package/src/domains/prompts/index.ts

@@ -12,69 +12,24 @@ export { createAIPromptTemplate, updateTemplateVersion, getTemplateString } from
 export type { GeneratedPrompt, CreateGeneratedPromptParams } from './domain/entities/GeneratedPrompt';
 export { createGeneratedPrompt, isPromptRecent } from './domain/entities/GeneratedPrompt';
 
-export type { FaceSwapConfig, FaceSwapTemplate, FaceSwapTemplateVariable, FaceSwapSafety, FaceSwapGenerationResult } from './domain/entities/FaceSwapConfig';
-export { validateFaceSwapConfig, createFaceSwapVariable } from './domain/entities/FaceSwapConfig';
-
-export type { PhotoRestorationConfig, PhotoRestorationTemplate, PhotoRestorationVariable, PhotoRestorationQuality, PhotoRestorationResult } from './domain/entities/PhotoRestorationConfig';
-export { validatePhotoRestorationConfig, createPhotoRestorationVariable, getQualityLevel } from './domain/entities/PhotoRestorationConfig';
-
-export type { ImageEnhancementConfig, ImageEnhancementTemplate, ImageEnhancementVariable, EnhancementSettings, ImageEnhancementResult, EnhancementAdjustments } from './domain/entities/ImageEnhancementConfig';
-export { validateImageEnhancementConfig, createImageEnhancementVariable, calculateAdjustments } from './domain/entities/ImageEnhancementConfig';
-
-export type { StyleTransferConfig, StyleTransferTemplate, StyleTransferVariable, StyleTransferSettings, StyleTransferResult } from './domain/entities/StyleTransferConfig';
-export { validateStyleTransferConfig, createStyleTransferVariable, getStyleStrengthValue, getArtisticModeDescription } from './domain/entities/StyleTransferConfig';
-
-export type { BackgroundRemovalConfig, BackgroundRemovalTemplate, BackgroundRemovalVariable, BackgroundRemovalSettings, BackgroundRemovalResult, DetectedObject } from './domain/entities/BackgroundRemovalConfig';
-export { validateBackgroundRemovalConfig, createBackgroundRemovalVariable, getProcessingTime, getQualityScore } from './domain/entities/BackgroundRemovalConfig';
-
-export type { TextGenerationConfig, TextGenerationTemplate, TextGenerationVariable, TextGenerationSettings, TextGenerationResult } from './domain/entities/TextGenerationConfig';
-export { validateTextGenerationConfig, createTextGenerationVariable, getTokenCount, getTemperature, getTopP } from './domain/entities/TextGenerationConfig';
-
-export type { ColorizationConfig, ColorizationTemplate, ColorizationVariable, ColorizationSettings, ColorizationResult } from './domain/entities/ColorizationConfig';
-export { validateColorizationConfig, createColorizationVariable, getColorizationQuality, getEraDescription, getSuggestedColorPalette } from './domain/entities/ColorizationConfig';
-
-export type { FuturePredictionConfig, FuturePredictionTemplate, FuturePredictionVariable, FuturePredictionSettings, FuturePredictionResult, FuturePredictionMetadata, FuturePredictionOutputType } from './domain/entities/FuturePredictionConfig';
-export { validateFuturePredictionConfig, createFuturePredictionVariable, getFutureYear } from './domain/entities/FuturePredictionConfig';
-export { IDENTITY_INSTRUCTION, createScenarioPrompt } from './infrastructure/services/FuturePredictionService';
-
+// Repository interfaces and implementations
 export type { ITemplateRepository } from './domain/repositories/ITemplateRepository';
 export type { IPromptHistoryRepository } from './domain/repositories/IPromptHistoryRepository';
-export type { IFaceSwapService, IPhotoRestorationService, IImageEnhancementService, IStyleTransferService, IBackgroundRemovalService, ITextGenerationService, IColorizationService, IPromptGenerationService, IFuturePredictionService } from './domain/repositories/IAIPromptServices';
+export type { IPromptGenerationService } from './domain/repositories/IAIPromptServices';
 
 export { TemplateRepository } from './infrastructure/repositories/TemplateRepository';
 export { PromptHistoryRepository } from './infrastructure/repositories/PromptHistoryRepository';
-
 export { PromptGenerationService } from './infrastructure/services/PromptGenerationService';
-export { FaceSwapService } from './infrastructure/services/FaceSwapService';
-export { PhotoRestorationService } from './infrastructure/services/PhotoRestorationService';
-export { ImageEnhancementService } from './infrastructure/services/ImageEnhancementService';
-export { StyleTransferService } from './infrastructure/services/StyleTransferService';
-export { BackgroundRemovalService } from './infrastructure/services/BackgroundRemovalService';
-export { TextGenerationService } from './infrastructure/services/TextGenerationService';
-export { ColorizationService } from './infrastructure/services/ColorizationService';
-export { FuturePredictionService } from './infrastructure/services/FuturePredictionService';
 
+// Async state hook
 export type { AsyncState, AsyncActions } from './presentation/hooks/useAsyncState';
 export { useAsyncState } from './presentation/hooks/useAsyncState';
 
+// Template repository hook
 export type { UseTemplateState, UseTemplateActions } from './presentation/hooks/useTemplateRepository';
 export { useTemplateRepository } from './presentation/hooks/useTemplateRepository';
 
-export type { UseFaceSwapState, UseFaceSwapActions } from './presentation/hooks/useFaceSwap';
-export { useFaceSwap } from './presentation/hooks/useFaceSwap';
-
-export type { UsePhotoRestorationState, UsePhotoRestorationActions } from './presentation/hooks/usePhotoRestoration';
-export { usePhotoRestoration } from './presentation/hooks/usePhotoRestoration';
-
-export type { UseImageEnhancementState, UseImageEnhancementActions } from './presentation/hooks/useImageEnhancement';
-export { useImageEnhancement } from './presentation/hooks/useImageEnhancement';
-
-export type { UseStyleTransferState, UseStyleTransferActions } from './presentation/hooks/useStyleTransfer';
-export { useStyleTransfer } from './presentation/hooks/useStyleTransfer';
-
-export type { UseAIServicesState, UseAIServicesActions } from './presentation/hooks/useAIServices';
-export { useAIServices } from './presentation/hooks/useAIServices';
-
+// Prompt generation hook
 export type { UsePromptGenerationState, UsePromptGenerationActions } from './presentation/hooks/usePromptGeneration';
 export { usePromptGeneration } from './presentation/hooks/usePromptGeneration';
 
@@ -97,9 +52,7 @@ export type { CreatePromptOptions } from './domain/entities/BasePromptStructure'
 
 export {
   MULTI_PERSON_PRESERVATION_RULES,
-  GENETIC_BLEND_RULES,
   createMultiPersonPrompt,
-  createGeneticBlendPrompt,
 } from './domain/entities/MultiPersonPromptStructure';
 export type { MultiPersonPreservationRules } from './domain/entities/MultiPersonPromptStructure';
 
@@ -116,6 +69,3 @@ export {
   getInteractionForbidden,
 } from './infrastructure/builders/interaction-style-builder';
 export type { InteractionStyle, InteractionStyleOptions } from './infrastructure/builders/interaction-style-builder';
-
-export { AIServiceProcessor } from './infrastructure/services/AIServiceProcessor';
-export type { AIConfig, AIServices, ProcessResult } from './infrastructure/services/AIServiceProcessor';

package/src/domains/scenarios/domain/Scenario.ts

@@ -16,9 +16,9 @@ export type ScenarioInputType = "single" | "dual" | "text";
 /**
  * Prompt type determines how multi-person prompts are built
  * - identity: Preserve exact facial features from input photos (default)
- * - genetic_blend: Create new face by blending features from multiple inputs (for child prediction)
+ * - custom: Use aiPrompt as-is without adding identity preservation (for app-specific scenarios)
  */
-export type ScenarioPromptType = "identity" | "genetic_blend";
+export type ScenarioPromptType = "identity" | "custom";
 
 export interface GeneratingMessages {
   title?: string;

package/src/domains/prompts/domain/entities/BackgroundRemovalConfig.ts

@@ -1,86 +0,0 @@
-import type { AIPromptTemplate } from './AIPromptTemplate';
-
-export interface BackgroundRemovalConfig {
-  precision: 'fast' | 'accurate' | 'ultra-accurate';
-  edgeRefinement: boolean;
-  preserveHair: boolean;
-  outputFormat: 'png' | 'webp' | 'transparent';
-  addNewBackground?: string;
-}
-
-export interface BackgroundRemovalTemplate {
-  readonly id: string;
-  readonly name: string;
-  readonly description: string;
-  readonly basePrompt: string;
-  readonly variables: BackgroundRemovalVariable[];
-  readonly processing: BackgroundRemovalSettings;
-}
-
-export interface BackgroundRemovalVariable {
-  name: string;
-  description: string;
-  required: boolean;
-  options?: string[];
-}
-
-export interface BackgroundRemovalSettings {
-  supportedFormats: string[];
-  maxResolution: number;
-  processingTimes: Record<string, number>;
-}
-
-export interface BackgroundRemovalResult {
-  template: AIPromptTemplate;
-  config: BackgroundRemovalConfig;
-  estimatedProcessingTime: number;
-  qualityScore: number;
-}
-
-export interface DetectedObject {
-  type: string;
-  confidence: number;
-  boundingBox: {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-  };
-}
-
-export const validateBackgroundRemovalConfig = (config: BackgroundRemovalConfig): boolean => {
-  return !!(
-    config.precision && 
-    config.outputFormat &&
-    ['png', 'webp', 'transparent'].includes(config.outputFormat)
-  );
-};
-
-export const createBackgroundRemovalVariable = (
-  name: string,
-  description: string,
-  required: boolean = true,
-  options?: string[]
-): BackgroundRemovalVariable => ({
-  name,
-  description,
-  required,
-  options,
-});
-
-export const getProcessingTime = (precision: BackgroundRemovalConfig['precision']): number => {
-  switch (precision) {
-    case 'fast': return 2;
-    case 'accurate': return 5;
-    case 'ultra-accurate': return 10;
-    default: return 5;
-  }
-};
-
-export const getQualityScore = (config: BackgroundRemovalConfig): number => {
-  let score = config.edgeRefinement ? 0.9 : 0.7;
-  if (config.preserveHair) score += 0.05;
-  if (config.precision === 'ultra-accurate') score += 0.15;
-  if (config.precision === 'accurate') score += 0.1;
-  return Math.min(score, 1.0);
-};

package/src/domains/prompts/domain/entities/ColorizationConfig.ts

@@ -1,101 +0,0 @@
-import type { AIPromptTemplate } from './AIPromptTemplate';
-
-export interface ColorizationConfig {
-  targetType: 'black-and-white' | 'sepia' | 'faded' | 'damaged';
-  colorMode: 'realistic' | 'vibrant' | 'artistic' | 'vintage';
-  preserveOriginal: boolean;
-  adjustLighting: boolean;
-  skinTonePreservation: boolean;
-  era?: '1920s' | '1940s' | '1960s' | '1980s' | 'victorian';
-}
-
-export interface ColorizationTemplate {
-  readonly id: string;
-  readonly name: string;
-  readonly description: string;
-  readonly basePrompt: string;
-  readonly variables: ColorizationVariable[];
-  readonly colorization: ColorizationSettings;
-}
-
-export interface ColorizationVariable {
-  name: string;
-  description: string;
-  required: boolean;
-  options?: string[];
-}
-
-export interface ColorizationSettings {
-  supportedModes: string[];
-  eraPresets: Record<string, string>;
-  skinToneAdjustments: number;
-}
-
-export interface ColorizationResult {
-  template: AIPromptTemplate;
-  config: ColorizationConfig;
-  qualityScore: number;
-  colorPalette?: string[];
-}
-
-export const validateColorizationConfig = (config: ColorizationConfig): boolean => {
-  return !!(
-    config.targetType &&
-    config.colorMode &&
-    ['realistic', 'vibrant', 'artistic', 'vintage'].includes(config.colorMode)
-  );
-};
-
-export const createColorizationVariable = (
-  name: string,
-  description: string,
-  required: boolean = true,
-  options?: string[]
-): ColorizationVariable => ({
-  name,
-  description,
-  required,
-  options,
-});
-
-export const getColorizationQuality = (config: ColorizationConfig): number => {
-  let quality = 0.8;
-
-  if (config.preserveOriginal) quality += 0.1;
-  if (config.skinTonePreservation) quality += 0.05;
-  if (config.colorMode === 'realistic') quality += 0.1;
-  if (config.targetType === 'black-and-white') quality += 0.05;
-
-  return Math.min(quality, 1.0);
-};
-
-export const getEraDescription = (era?: string): string => {
-  switch (era) {
-    case '1920s': return '1920s vintage aesthetic with soft colors';
-    case '1940s': return '1940s wartime color palette';
-    case '1960s': return '1960s vibrant, saturated colors';
-    case '1980s': return '1980s neon and pastel tones';
-    case 'victorian': return 'Victorian era muted, elegant colors';
-    default: return 'Historically appropriate color palette';
-  }
-};
-
-export const getSuggestedColorPalette = (
-  targetType: ColorizationConfig['targetType'],
-  colorMode: ColorizationConfig['colorMode']
-): string[] => {
-  switch (targetType) {
-    case 'black-and-white':
-      return colorMode === 'vibrant'
-        ? ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4', '#FFEAA7']
-        : ['#2C3E50', '#34495E', '#7F8C8D', '#95A5A6', '#BDC3C7'];
-    case 'sepia':
-      return ['#8B7355', '#A0826D', '#BC9A6A', '#D2B48C', '#DEB887'];
-    case 'faded':
-      return ['#E27D60', '#41B3A3', '#85DCBA', '#C1E1DC', '#E8DDCB'];
-    case 'damaged':
-      return ['#C9302C', '#F0AD4E', '#5BC0DE', '#5CB85C'];
-    default:
-      return [];
-  }
-};

package/src/domains/prompts/domain/entities/FaceSwapConfig.ts

@@ -1,54 +0,0 @@
-import type { AIPromptTemplate } from './AIPromptTemplate';
-import type { GeneratedPrompt } from './GeneratedPrompt';
-
-export interface FaceSwapConfig {
-  preserveIdentity: boolean;
-  allowHairStyle: boolean;
-  allowAccessories: boolean;
-  allowExpression: boolean;
-  environment?: string;
-  styleName: string;
-}
-
-export interface FaceSwapTemplate {
-  readonly id: string;
-  readonly name: string;
-  readonly description: string;
-  readonly basePrompt: string;
-  readonly variables: FaceSwapTemplateVariable[];
-  readonly safety: FaceSwapSafety;
-}
-
-export interface FaceSwapTemplateVariable {
-  name: string;
-  description: string;
-  required: boolean;
-  options?: string[];
-}
-
-export interface FaceSwapSafety {
-  contentFilter: boolean;
-  identityPreservation: boolean;
-  adultContentFilter: boolean;
-}
-
-export interface FaceSwapGenerationResult {
-  template: AIPromptTemplate;
-  prompt: GeneratedPrompt;
-}
-
-export const validateFaceSwapConfig = (config: FaceSwapConfig): boolean => {
-  return !!(config.styleName && config.styleName.trim().length > 0);
-};
-
-export const createFaceSwapVariable = (
-  name: string,
-  description: string,
-  required: boolean = true,
-  options?: string[]
-): FaceSwapTemplateVariable => ({
-  name,
-  description,
-  required,
-  options,
-});

package/src/domains/prompts/domain/entities/FuturePredictionConfig.ts

@@ -1,94 +0,0 @@
-import type { AIPromptVariable } from './value-objects';
-
-/**
- * Future Prediction Configuration
- * Generic configuration for generating future scenarios/visualizations
- */
-
-export interface FuturePredictionSettings {
-    readonly scenarioType: string; // e.g. 'lifestyle', 'career', 'family', 'adventure'
-    readonly outputType: FuturePredictionOutputType;
-    readonly personCount: 1 | 2;
-    readonly includeDate: boolean;
-    readonly language: string; // Language code (e.g. 'en', 'tr')
-    readonly languageName?: string; // Full language name provided by app (e.g. 'Turkish', 'English')
-    readonly tone?: string; // e.g. 'romantic', 'professional', 'funny', 'dramatic'
-    readonly subjectRole?: string; // e.g. 'couple', 'best friends', 'business partners', 'parents'
-    readonly year?: number; // Optional specific year for prediction
-}
-
-export type FuturePredictionOutputType = 'image' | 'story' | 'both';
-
-export interface FuturePredictionConfig {
-    readonly scenarioId: string;
-    readonly scenarioTitle: string;
-    readonly promptModifier: string;
-    readonly subjectA: string;
-    readonly subjectB?: string;
-    readonly settings: FuturePredictionSettings;
-    readonly customPrompt?: string;
-}
-
-export interface FuturePredictionTemplate {
-    readonly id: string;
-    readonly name: string;
-    readonly description: string;
-    readonly imagePrompt: string;
-    readonly storyPrompt: string;
-    readonly variables: readonly FuturePredictionVariable[];
-}
-
-export interface FuturePredictionVariable extends AIPromptVariable {
-    readonly category: 'subject' | 'scenario' | 'output';
-}
-
-export interface FuturePredictionResult {
-    readonly imagePrompt: string;
-    readonly storyPrompt: string;
-    readonly metadata: FuturePredictionMetadata;
-}
-
-export interface FuturePredictionMetadata {
-    readonly scenarioId: string;
-    readonly personCount: number;
-    readonly language: string;
-    readonly generatedAt: number;
-}
-
-export const validateFuturePredictionConfig = (
-    config: FuturePredictionConfig
-): boolean => {
-    if (!config.scenarioId || typeof config.scenarioId !== 'string') {
-        return false;
-    }
-    if (!config.subjectA || typeof config.subjectA !== 'string') {
-        return false;
-    }
-    if (!config.settings) {
-        return false;
-    }
-    return true;
-};
-
-export const createFuturePredictionVariable = (
-    name: string,
-    type: 'string' | 'number' | 'boolean',
-    description: string,
-    category: 'subject' | 'scenario' | 'output',
-    required: boolean = true,
-    defaultValue?: string | number | boolean
-): FuturePredictionVariable => ({
-    name,
-    type,
-    description,
-    category,
-    required,
-    defaultValue,
-});
-
-export const getFutureYear = (): number => {
-    const currentYear = new Date().getFullYear();
-    // Typical future predictions are 1-50 years ahead
-    const offset = 1 + Math.floor(Math.random() * 50);
-    return currentYear + offset;
-};