impl fal http requests for text-to-image webhooks

crates/api_clients/fal_client/src/requests/http/image/text/http_flux_1_dev_text_to_image.rs

@@ -0,0 +1,47 @@
+use fal::request::FalRequest;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct Flux1DevTextToImageInput {
+  pub prompt: String,
+
+  /// Options: square_hd, square, portrait_4_3, portrait_16_9, landscape_4_3, landscape_16_9
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub image_size: Option<String>,
+
+  /// 1 - 4
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub num_images: Option<i64>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub seed: Option<i64>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub guidance_scale: Option<f64>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub num_inference_steps: Option<i64>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub enable_safety_checker: Option<bool>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub sync_mode: Option<bool>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Flux1DevTextToImageFile {
+  pub url: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Flux1DevTextToImageOutput {
+  pub images: Vec<Flux1DevTextToImageFile>,
+}
+
+pub fn flux_1_dev_text_to_image(
+  params: Flux1DevTextToImageInput,
+) -> FalRequest<Flux1DevTextToImageInput, Flux1DevTextToImageOutput> {
+  FalRequest::new("fal-ai/flux/dev", params)
+}

crates/api_clients/fal_client/src/requests/http/image/text/http_flux_1_schnell_text_to_image.rs

@@ -0,0 +1,44 @@
+use fal::request::FalRequest;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct Flux1SchnellTextToImageInput {
+  pub prompt: String,
+
+  /// Options: square_hd, square, portrait_4_3, portrait_16_9, landscape_4_3, landscape_16_9
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub image_size: Option<String>,
+
+  /// 1 - 4
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub num_images: Option<i64>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub seed: Option<i64>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub num_inference_steps: Option<i64>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub enable_safety_checker: Option<bool>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub sync_mode: Option<bool>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Flux1SchnellTextToImageFile {
+  pub url: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Flux1SchnellTextToImageOutput {
+  pub images: Vec<Flux1SchnellTextToImageFile>,
+}
+
+pub fn flux_1_schnell_text_to_image(
+  params: Flux1SchnellTextToImageInput,
+) -> FalRequest<Flux1SchnellTextToImageInput, Flux1SchnellTextToImageOutput> {
+  FalRequest::new("fal-ai/flux/schnell", params)
+}

crates/api_clients/fal_client/src/requests/http/image/text/http_flux_pro_11_text_to_image.rs

@@ -0,0 +1,50 @@
+use fal::request::FalRequest;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct FluxPro11TextToImageInput {
+  pub prompt: String,
+
+  /// Options: square_hd, square, portrait_4_3, portrait_16_9, landscape_4_3, landscape_16_9
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub image_size: Option<String>,
+
+  /// 1 - 4
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub num_images: Option<i64>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub seed: Option<i64>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub enable_safety_checker: Option<bool>,
+
+  /// "1" (most strict) to "5" (most permissive)
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub safety_tolerance: Option<String>,
+
+  /// "png" or "jpeg"
+  /// Default: "jpeg"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub output_format: Option<String>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub sync_mode: Option<bool>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct FluxPro11TextToImageFile {
+  pub url: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct FluxPro11TextToImageOutput {
+  pub images: Vec<FluxPro11TextToImageFile>,
+}
+
+pub fn flux_pro_11_text_to_image(
+  params: FluxPro11TextToImageInput,
+) -> FalRequest<FluxPro11TextToImageInput, FluxPro11TextToImageOutput> {
+  FalRequest::new("fal-ai/flux-pro/v1.1", params)
+}

crates/api_clients/fal_client/src/requests/http/image/text/http_flux_pro_11_ultra_text_to_image.rs

@@ -0,0 +1,55 @@
+use fal::request::FalRequest;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct FluxPro11UltraTextToImageInput {
+  pub prompt: String,
+
+  /// Options: 21:9, 16:9, 4:3, 3:2, 1:1, 2:3, 3:4, 9:16, 9:21
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub aspect_ratio: Option<String>,
+
+  /// 1 - 4
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub num_images: Option<i64>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub seed: Option<i64>,
+
+  /// Generate less processed, more natural-looking images.
+  /// Default: false
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub raw: Option<bool>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub enable_safety_checker: Option<bool>,
+
+  /// "1" (most strict) to "5" (most permissive)
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub safety_tolerance: Option<String>,
+
+  /// "png" or "jpeg"
+  /// Default: "jpeg"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub output_format: Option<String>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub sync_mode: Option<bool>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct FluxPro11UltraTextToImageFile {
+  pub url: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct FluxPro11UltraTextToImageOutput {
+  pub images: Vec<FluxPro11UltraTextToImageFile>,
+}
+
+pub fn flux_pro_11_ultra_text_to_image(
+  params: FluxPro11UltraTextToImageInput,
+) -> FalRequest<FluxPro11UltraTextToImageInput, FluxPro11UltraTextToImageOutput> {
+  FalRequest::new("fal-ai/flux-pro/v1.1-ultra", params)
+}

crates/api_clients/fal_client/src/requests/http/image/text/http_gemini_25_flash_text_to_image.rs

@@ -0,0 +1,38 @@
+use fal::request::FalRequest;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct Gemini25FlashTextToImageInput {
+  pub prompt: String,
+
+  /// 1 - 4
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub num_images: Option<u8>,
+
+  /// "jpeg" or "png"
+  /// Default: "png"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub output_format: Option<String>,
+
+  /// Options: 21:9, 16:9, 3:2, 4:3, 5:4, 1:1, 4:5, 3:4, 2:3, 9:16
+  /// Default: "1:1"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub aspect_ratio: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Gemini25FlashTextToImageFile {
+  pub url: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Gemini25FlashTextToImageOutput {
+  pub images: Vec<Gemini25FlashTextToImageFile>,
+}
+
+pub fn gemini_25_flash_text_to_image(
+  params: Gemini25FlashTextToImageInput,
+) -> FalRequest<Gemini25FlashTextToImageInput, Gemini25FlashTextToImageOutput> {
+  FalRequest::new("fal-ai/gemini-25-flash-image", params)
+}

crates/api_clients/fal_client/src/requests/http/image/text/http_gpt_image_1_text_to_image.rs

@@ -0,0 +1,30 @@
+use fal::request::FalRequest;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct GptImage1TextToImageInput {
+  pub prompt: String,
+
+  /// "auto", "1024x1024", "1536x1024", "1024x1536"
+  pub image_size: String,
+
+  /// 1 - 4
+  pub num_images: u8,
+
+  /// "auto", "low", "medium", "high"
+  pub quality: String,
+
+  /// BYOK - caller supplies their own OpenAI API key
+  pub openai_api_key: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct GptImage1TextToImageOutput {
+  // Response fields parsed elsewhere
+}
+
+pub fn gpt_image_1_text_to_image(
+  params: GptImage1TextToImageInput,
+) -> FalRequest<GptImage1TextToImageInput, GptImage1TextToImageOutput> {
+  FalRequest::new("fal-ai/gpt-image-1/text-to-image/byok", params)
+}

crates/api_clients/fal_client/src/requests/http/image/text/http_gpt_image_1p5_text_to_image.rs

@@ -0,0 +1,45 @@
+use fal::request::FalRequest;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct GptImage1p5TextToImageInput {
+  pub prompt: String,
+
+  /// "auto", "1024x1024", "1536x1024", "1024x1536"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub image_size: Option<String>,
+
+  /// "auto", "transparent", "opaque"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub background: Option<String>,
+
+  /// "low", "medium", "high"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub quality: Option<String>,
+
+  /// 1 - 4
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub num_images: Option<u8>,
+
+  /// "jpeg", "png", "webp"
+  /// Default: "png"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub output_format: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct GptImage1p5TextToImageFile {
+  pub url: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct GptImage1p5TextToImageOutput {
+  pub images: Vec<GptImage1p5TextToImageFile>,
+}
+
+pub fn gpt_image_1p5_text_to_image(
+  params: GptImage1p5TextToImageInput,
+) -> FalRequest<GptImage1p5TextToImageInput, GptImage1p5TextToImageOutput> {
+  FalRequest::new("fal-ai/gpt-image-1.5", params)
+}

crates/api_clients/fal_client/src/requests/http/image/text/http_nano_banana_pro_text_to_image.rs

@@ -0,0 +1,43 @@
+use fal::request::FalRequest;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct NanoBananaProTextToImageInput {
+  pub prompt: String,
+
+  /// Options: auto, 21:9, 16:9, 3:2, 4:3, 5:4, 1:1, 4:5, 3:4, 2:3, 9:16
+  /// Default: "auto"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub aspect_ratio: Option<String>,
+
+  /// "1K", "2K", "4K"
+  /// Default: "1K"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub resolution: Option<String>,
+
+  /// 1 - 4
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub num_images: Option<u8>,
+
+  /// "jpeg", "png", "webp"
+  /// Default: "png"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub output_format: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct NanoBananaProTextToImageFile {
+  pub url: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct NanoBananaProTextToImageOutput {
+  pub images: Vec<NanoBananaProTextToImageFile>,
+}
+
+pub fn nano_banana_pro_text_to_image(
+  params: NanoBananaProTextToImageInput,
+) -> FalRequest<NanoBananaProTextToImageInput, NanoBananaProTextToImageOutput> {
+  FalRequest::new("fal-ai/nano-banana-pro", params)
+}

crates/api_clients/fal_client/src/requests/http/image/text/http_seedream_4_text_to_image.rs

@@ -0,0 +1,47 @@
+use fal::request::FalRequest;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct SeedreamV4TextToImageInput {
+  pub prompt: String,
+
+  /// Options: square_hd, square, portrait_4_3, portrait_16_9, landscape_4_3, landscape_16_9, auto, auto_2K, auto_4K
+  /// Default: "auto_2K"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub image_size: Option<String>,
+
+  /// 1 - 4
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub num_images: Option<u8>,
+
+  /// 1 - 4
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub max_images: Option<u8>,
+
+  /// Enum: "standard", "fast"
+  /// Default: "standard"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub enhance_prompt_mode: Option<String>,
+
+  /// Default: true
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub enable_safety_checker: Option<bool>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SeedreamV4TextToImageFile {
+  pub url: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SeedreamV4TextToImageOutput {
+  pub images: Vec<SeedreamV4TextToImageFile>,
+}
+
+pub fn seedream_4_text_to_image(
+  params: SeedreamV4TextToImageInput,
+) -> FalRequest<SeedreamV4TextToImageInput, SeedreamV4TextToImageOutput> {
+  FalRequest::new("fal-ai/bytedance/seedream/v4/text-to-image", params)
+}

crates/api_clients/fal_client/src/requests/http/image/text/http_seedream_4p5_text_to_image.rs

@@ -0,0 +1,45 @@
+use fal::request::FalRequest;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct SeedreamV4p5TextToImageInput {
+  pub prompt: String,
+
+  /// Options: square_hd, square, portrait_4_3, portrait_16_9, landscape_4_3, landscape_16_9, auto_2K, auto_4K
+  /// Default: "auto_2K"
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub image_size: Option<String>,
+
+  /// 1 - 4
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub num_images: Option<u8>,
+
+  /// 1 - 4
+  /// Default: 1
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub max_images: Option<u8>,
+
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub seed: Option<i64>,
+
+  /// Default: true
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub enable_safety_checker: Option<bool>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SeedreamV4p5TextToImageFile {
+  pub url: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct SeedreamV4p5TextToImageOutput {
+  pub images: Vec<SeedreamV4p5TextToImageFile>,
+}
+
+pub fn seedream_4p5_text_to_image(
+  params: SeedreamV4p5TextToImageInput,
+) -> FalRequest<SeedreamV4p5TextToImageInput, SeedreamV4p5TextToImageOutput> {
+  FalRequest::new("fal-ai/bytedance/seedream/v4.5/text-to-image", params)
+}

crates/api_clients/fal_client/src/requests/http/image/text/mod.rs

@@ -1,2 +1,12 @@
+pub mod http_flux_1_dev_text_to_image;
+pub mod http_flux_1_schnell_text_to_image;
+pub mod http_flux_pro_11_text_to_image;
+pub mod http_flux_pro_11_ultra_text_to_image;
+pub mod http_gemini_25_flash_text_to_image;
+pub mod http_gpt_image_1_text_to_image;
+pub mod http_gpt_image_1p5_text_to_image;
 pub mod http_nano_banana_2_text_to_image;
+pub mod http_nano_banana_pro_text_to_image;
+pub mod http_seedream_4_text_to_image;
+pub mod http_seedream_4p5_text_to_image;
 pub mod http_seedream_5_text_to_image;

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_bytedance_seedream_v4_text_to_image_webhook.rs

@@ -2,8 +2,7 @@ use crate::creds::fal_api_key::FalApiKey;
 use crate::error::classify_fal_error::classify_fal_error;
 use crate::error::fal_error_plus::FalErrorPlus;
 use crate::requests::traits::fal_request_cost_calculator_trait::{FalRequestCostCalculator, UsdCents};
-use fal::endpoints::fal_ai::bytedance::seedream::bytedance_seedream_v4_text_to_image::BytedanceSeedreamV4TextToImageInput;
-use fal::prelude::fal_ai::bytedance::seedream::bytedance_seedream_v4_text_to_image::bytedance_seedream_v4_text_to_image;
+use crate::requests::http::image::text::http_seedream_4_text_to_image::{seedream_4_text_to_image, SeedreamV4TextToImageInput};
 use fal::webhook::WebhookResponse;
 use reqwest::IntoUrl;
 
@@ -106,7 +105,7 @@ pub async fn enqueue_bytedance_seedream_v4_text_to_image_webhook<R: IntoUrl>(
       })
       .map(|resolution| resolution.to_string());
 
-  let request = BytedanceSeedreamV4TextToImageInput {
+  let request = SeedreamV4TextToImageInput {
     prompt: args.prompt.to_string(),
     // Optionals
     num_images,
@@ -117,7 +116,7 @@ pub async fn enqueue_bytedance_seedream_v4_text_to_image_webhook<R: IntoUrl>(
     enable_safety_checker: Some(false),
   };
 
-  let result = bytedance_seedream_v4_text_to_image(request)
+  let result = seedream_4_text_to_image(request)
       .with_api_key(&args.api_key.0)
       .queue_webhook(args.webhook_url)
       .await;

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_bytedance_seedream_v4p5_text_to_image_webhook.rs

@@ -1,7 +1,7 @@
 use crate::creds::fal_api_key::FalApiKey;
 use crate::error::classify_fal_error::classify_fal_error;
 use crate::error::fal_error_plus::FalErrorPlus;
-use fal::endpoints::fal_ai::bytedance::seedream::bytedance_seedream_v4p5_text_to_image::{bytedance_seedream_v4p5_text_to_image, BytedanceSeedreamV4p5TextToImageInput};
+use crate::requests::http::image::text::http_seedream_4p5_text_to_image::{seedream_4p5_text_to_image, SeedreamV4p5TextToImageInput};
 use fal::webhook::WebhookResponse;
 use reqwest::IntoUrl;
 use crate::requests::traits::fal_request_cost_calculator_trait::{FalRequestCostCalculator, UsdCents};
@@ -104,7 +104,7 @@ pub async fn enqueue_bytedance_seedream_v4p5_text_to_image_webhook<R: IntoUrl>(
       })
       .map(|resolution| resolution.to_string());
 
-  let request = BytedanceSeedreamV4p5TextToImageInput {
+  let request = SeedreamV4p5TextToImageInput {
     prompt: args.prompt.to_string(),
     // Optionals
     num_images,
@@ -115,7 +115,7 @@ pub async fn enqueue_bytedance_seedream_v4p5_text_to_image_webhook<R: IntoUrl>(
     seed: None,
   };
 
-  let result = bytedance_seedream_v4p5_text_to_image(request)
+  let result = seedream_4p5_text_to_image(request)
       .with_api_key(&args.api_key.0)
       .queue_webhook(args.webhook_url)
       .await;

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_flux_1_dev_text_to_image_webhook.rs

@@ -1,9 +1,7 @@
 use crate::creds::fal_api_key::FalApiKey;
 use crate::error::classify_fal_error::classify_fal_error;
 use crate::error::fal_error_plus::FalErrorPlus;
-use fal::endpoints::fal_ai::flux::dev::dev;
-use fal::endpoints::fal_ai::flux::dev::DevTextToImageInput;
-use fal::prelude::fal_ai::flux::dev::ImageSizeProperty;
+use crate::requests::http::image::text::http_flux_1_dev_text_to_image::{flux_1_dev_text_to_image, Flux1DevTextToImageInput};
 use fal::webhook::WebhookResponse;
 use reqwest::IntoUrl;
 
@@ -46,18 +44,18 @@ pub async fn enqueue_flux_1_dev_text_to_image_webhook<U: IntoUrl>(
   };
 
   let image_size = match args.aspect_ratio {
-    Flux1DevAspectRatio::Square => ImageSizeProperty::Square,
-    Flux1DevAspectRatio::SquareHd => ImageSizeProperty::SquareHd,
-    Flux1DevAspectRatio::LandscapeFourByThree => ImageSizeProperty::Landscape43,
-    Flux1DevAspectRatio::LandscapeSixteenByNine => ImageSizeProperty::Landscape169,
-    Flux1DevAspectRatio::PortraitThreeByFour => ImageSizeProperty::Portrait43,
-    Flux1DevAspectRatio::PortraitNineBySixteen => ImageSizeProperty::Portrait169,
+    Flux1DevAspectRatio::Square => "square",
+    Flux1DevAspectRatio::SquareHd => "square_hd",
+    Flux1DevAspectRatio::LandscapeFourByThree => "landscape_4_3",
+    Flux1DevAspectRatio::LandscapeSixteenByNine => "landscape_16_9",
+    Flux1DevAspectRatio::PortraitThreeByFour => "portrait_4_3",
+    Flux1DevAspectRatio::PortraitNineBySixteen => "portrait_16_9",
   };
 
-  let request = DevTextToImageInput {
+  let request = Flux1DevTextToImageInput {
     prompt: args.prompt.to_string(),
     num_images: Some(num_images),
-    image_size: Some(image_size),
+    image_size: Some(image_size.to_string()),
     // Maybe abstract
     enable_safety_checker: Some(false),
     // Maybe expose
@@ -68,7 +66,7 @@ pub async fn enqueue_flux_1_dev_text_to_image_webhook<U: IntoUrl>(
     sync_mode: None, // Synchronous / slow
   };
 
-  let result = dev(request)
+  let result = flux_1_dev_text_to_image(request)
       .with_api_key(&args.api_key.0)
       .queue_webhook(args.webhook_url)
       .await;

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_flux_1_schnell_text_to_image_webhook.rs

@@ -1,9 +1,7 @@
 use crate::creds::fal_api_key::FalApiKey;
 use crate::error::classify_fal_error::classify_fal_error;
 use crate::error::fal_error_plus::FalErrorPlus;
-use fal::endpoints::fal_ai::flux::schnell::schnell;
-use fal::endpoints::fal_ai::flux::schnell::SchnellTextToImageInput;
-use fal::prelude::fal_ai::flux::schnell::ImageSizeProperty;
+use crate::requests::http::image::text::http_flux_1_schnell_text_to_image::{flux_1_schnell_text_to_image, Flux1SchnellTextToImageInput};
 use fal::webhook::WebhookResponse;
 use reqwest::IntoUrl;
 
@@ -46,18 +44,18 @@ pub async fn enqueue_flux_1_schnell_text_to_image_webhook<U: IntoUrl>(
   };
 
   let image_size = match args.aspect_ratio {
-    Flux1SchnellAspectRatio::Square => ImageSizeProperty::Square,
-    Flux1SchnellAspectRatio::SquareHd => ImageSizeProperty::SquareHd,
-    Flux1SchnellAspectRatio::LandscapeFourByThree => ImageSizeProperty::Landscape43,
-    Flux1SchnellAspectRatio::LandscapeSixteenByNine => ImageSizeProperty::Landscape169,
-    Flux1SchnellAspectRatio::PortraitThreeByFour => ImageSizeProperty::Portrait43,
-    Flux1SchnellAspectRatio::PortraitNineBySixteen => ImageSizeProperty::Portrait169,
+    Flux1SchnellAspectRatio::Square => "square",
+    Flux1SchnellAspectRatio::SquareHd => "square_hd",
+    Flux1SchnellAspectRatio::LandscapeFourByThree => "landscape_4_3",
+    Flux1SchnellAspectRatio::LandscapeSixteenByNine => "landscape_16_9",
+    Flux1SchnellAspectRatio::PortraitThreeByFour => "portrait_4_3",
+    Flux1SchnellAspectRatio::PortraitNineBySixteen => "portrait_16_9",
   };
 
-  let request = SchnellTextToImageInput {
+  let request = Flux1SchnellTextToImageInput {
     prompt: args.prompt.to_string(),
     num_images: Some(num_images),
-    image_size: Some(image_size),
+    image_size: Some(image_size.to_string()),
     // Maybe abstract
     enable_safety_checker: Some(false),
     // Maybe expose
@@ -67,7 +65,7 @@ pub async fn enqueue_flux_1_schnell_text_to_image_webhook<U: IntoUrl>(
     sync_mode: None, // Synchronous / slow
   };
 
-  let result = schnell(request)
+  let result = flux_1_schnell_text_to_image(request)
       .with_api_key(&args.api_key.0)
       .queue_webhook(args.webhook_url)
       .await;

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_flux_pro_11_text_to_image_webhook.rs

@@ -2,7 +2,7 @@ use crate::creds::fal_api_key::FalApiKey;
 use crate::error::classify_fal_error::classify_fal_error;
 use crate::error::fal_error_plus::FalErrorPlus;
 use crate::requests::traits::fal_request_cost_calculator_trait::{FalRequestCostCalculator, UsdCents};
-use fal::endpoints::fal_ai::flux_pro::v1_1::{v1_1, FluxProPlusTextToImageInput, ImageSizeProperty};
+use crate::requests::http::image::text::http_flux_pro_11_text_to_image::{flux_pro_11_text_to_image, FluxPro11TextToImageInput};
 use fal::webhook::WebhookResponse;
 use reqwest::IntoUrl;
 
@@ -62,18 +62,18 @@ pub async fn enqueue_flux_pro_11_text_to_image_webhook<U: IntoUrl>(
   };
 
   let image_size = match args.aspect_ratio {
-    FluxPro11AspectRatio::Square => ImageSizeProperty::Square,
-    FluxPro11AspectRatio::SquareHd => ImageSizeProperty::SquareHd,
-    FluxPro11AspectRatio::LandscapeFourByThree => ImageSizeProperty::Landscape43,
-    FluxPro11AspectRatio::LandscapeSixteenByNine => ImageSizeProperty::Landscape169,
-    FluxPro11AspectRatio::PortraitThreeByFour => ImageSizeProperty::Portrait43,
-    FluxPro11AspectRatio::PortraitNineBySixteen => ImageSizeProperty::Portrait169,
+    FluxPro11AspectRatio::Square => "square",
+    FluxPro11AspectRatio::SquareHd => "square_hd",
+    FluxPro11AspectRatio::LandscapeFourByThree => "landscape_4_3",
+    FluxPro11AspectRatio::LandscapeSixteenByNine => "landscape_16_9",
+    FluxPro11AspectRatio::PortraitThreeByFour => "portrait_4_3",
+    FluxPro11AspectRatio::PortraitNineBySixteen => "portrait_16_9",
   };
 
-  let request = FluxProPlusTextToImageInput {
+  let request = FluxPro11TextToImageInput {
     prompt: args.prompt.to_string(),
     num_images: Some(num_images),
-    image_size: Some(image_size),
+    image_size: Some(image_size.to_string()),
     // Maybe expose
     seed: None,
     // Maybe abstract
@@ -84,7 +84,7 @@ pub async fn enqueue_flux_pro_11_text_to_image_webhook<U: IntoUrl>(
     sync_mode: None, // Synchronous / slow
   };
 
-  let result = v1_1(request)
+  let result = flux_pro_11_text_to_image(request)
       .with_api_key(&args.api_key.0)
       .queue_webhook(args.webhook_url)
       .await;

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_flux_pro_11_ultra_text_to_image_webhook.rs

@@ -2,7 +2,7 @@ use crate::creds::fal_api_key::FalApiKey;
 use crate::error::classify_fal_error::classify_fal_error;
 use crate::error::fal_error_plus::FalErrorPlus;
 use crate::requests::traits::fal_request_cost_calculator_trait::{FalRequestCostCalculator, UsdCents};
-use fal::endpoints::fal_ai::flux_pro::v1_1_ultra::{v1_1_ultra, AspectRatioProperty, FluxProUltraTextToImageInput};
+use crate::requests::http::image::text::http_flux_pro_11_ultra_text_to_image::{flux_pro_11_ultra_text_to_image, FluxPro11UltraTextToImageInput};
 use fal::webhook::WebhookResponse;
 use reqwest::IntoUrl;
 
@@ -64,21 +64,21 @@ pub async fn enqueue_flux_pro_11_ultra_text_to_image_webhook<U: IntoUrl>(
   };
 
   let aspect_ratio = match args.aspect_ratio {
-    FluxPro11UltraAspectRatio::Square => AspectRatioProperty::Property_1_1,
-    FluxPro11UltraAspectRatio::LandscapeThreeByTwo => AspectRatioProperty::Property_3_2,
-    FluxPro11UltraAspectRatio::LandscapeFourByThree => AspectRatioProperty::Property_4_3,
-    FluxPro11UltraAspectRatio::LandscapeSixteenByNine => AspectRatioProperty::Property_16_9,
-    FluxPro11UltraAspectRatio::LandscapeTwentyOneByNine => AspectRatioProperty::Property_21_9,
-    FluxPro11UltraAspectRatio::PortraitTwoByThree => AspectRatioProperty::Property_2_3,
-    FluxPro11UltraAspectRatio::PortraitThreeByFour => AspectRatioProperty::Property_3_4,
-    FluxPro11UltraAspectRatio::PortraitNineBySixteen => AspectRatioProperty::Property_9_16,
-    FluxPro11UltraAspectRatio::PortraitNineByTwentyOne => AspectRatioProperty::Property_9_21,
+    FluxPro11UltraAspectRatio::Square => "1:1",
+    FluxPro11UltraAspectRatio::LandscapeThreeByTwo => "3:2",
+    FluxPro11UltraAspectRatio::LandscapeFourByThree => "4:3",
+    FluxPro11UltraAspectRatio::LandscapeSixteenByNine => "16:9",
+    FluxPro11UltraAspectRatio::LandscapeTwentyOneByNine => "21:9",
+    FluxPro11UltraAspectRatio::PortraitTwoByThree => "2:3",
+    FluxPro11UltraAspectRatio::PortraitThreeByFour => "3:4",
+    FluxPro11UltraAspectRatio::PortraitNineBySixteen => "9:16",
+    FluxPro11UltraAspectRatio::PortraitNineByTwentyOne => "9:21",
   };
 
-  let request = FluxProUltraTextToImageInput {
+  let request = FluxPro11UltraTextToImageInput {
     prompt: args.prompt.to_string(),
     num_images: Some(num_images),
-    aspect_ratio: Some(aspect_ratio),
+    aspect_ratio: Some(aspect_ratio.to_string()),
     // Maybe expose
     seed: None,
     raw: Some(true), // Generate less processed, more natural-looking images. Default is false.
@@ -90,7 +90,7 @@ pub async fn enqueue_flux_pro_11_ultra_text_to_image_webhook<U: IntoUrl>(
     sync_mode: None, // Synchronous / slow
   };
 
-  let result = v1_1_ultra(request)
+  let result = flux_pro_11_ultra_text_to_image(request)
       .with_api_key(&args.api_key.0)
       .queue_webhook(args.webhook_url)
       .await;

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_gemini_25_flash_text_to_image_webhook.rs

@@ -1,8 +1,7 @@
 use crate::creds::fal_api_key::FalApiKey;
 use crate::error::classify_fal_error::classify_fal_error;
 use crate::error::fal_error_plus::FalErrorPlus;
-use fal::prelude::fal_ai::gemini_25_flash_image::text_to_image::gemini_25_flash_text_to_image;
-use fal::prelude::fal_ai::gemini_25_flash_image::text_to_image::Gemini25FlashTextToImageInput;
+use crate::requests::http::image::text::http_gemini_25_flash_text_to_image::{gemini_25_flash_text_to_image, Gemini25FlashTextToImageInput};
 use fal::webhook::WebhookResponse;
 use reqwest::IntoUrl;
 use crate::requests::traits::fal_request_cost_calculator_trait::{FalRequestCostCalculator, UsdCents};

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_gpt_image_1_text_to_image_webhook.rs

@@ -3,7 +3,7 @@ use crate::creds::open_ai_api_key::OpenAiApiKey;
 use crate::error::classify_fal_error::classify_fal_error;
 use crate::error::fal_error_plus::FalErrorPlus;
 use crate::requests::traits::fal_request_cost_calculator_trait::{FalRequestCostCalculator, UsdCents};
-use fal::prelude::fal_ai::gpt_image_1::edit_image::byok::{gpt_text_to_image, GptTextToImageRequest};
+use crate::requests::http::image::text::http_gpt_image_1_text_to_image::{gpt_image_1_text_to_image, GptImage1TextToImageInput};
 use fal::webhook::WebhookResponse;
 use reqwest::IntoUrl;
 
@@ -95,7 +95,7 @@ pub async fn enqueue_gpt_image_1_text_to_image_webhook<V: IntoUrl>(
     GptTextToImageNumImages::Four => 4,
   };
 
-  let request = GptTextToImageRequest {
+  let request = GptImage1TextToImageInput {
     prompt: args.prompt.to_string(),
     image_size: image_size.to_string(),
     num_images,
@@ -103,7 +103,7 @@ pub async fn enqueue_gpt_image_1_text_to_image_webhook<V: IntoUrl>(
     openai_api_key: args.openai_api_key.0.to_string(),
   };
 
-  let result = gpt_text_to_image(request)
+  let result = gpt_image_1_text_to_image(request)
       .with_api_key(&args.api_key.0)
       .queue_webhook(args.webhook_url)
       .await;

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_gpt_image_1p5_text_to_image_webhook.rs

@@ -2,7 +2,7 @@ use crate::creds::fal_api_key::FalApiKey;
 use crate::error::classify_fal_error::classify_fal_error;
 use crate::error::fal_error_plus::FalErrorPlus;
 use crate::requests::traits::fal_request_cost_calculator_trait::{FalRequestCostCalculator, UsdCents};
-use fal::endpoints::fal_ai::gpt_image::gpt_image_1p5_text_to_image::{gpt_image_1p5_text_to_image, GptImage1p5TextToImageInput};
+use crate::requests::http::image::text::http_gpt_image_1p5_text_to_image::{gpt_image_1p5_text_to_image, GptImage1p5TextToImageInput};
 use fal::webhook::WebhookResponse;
 use reqwest::IntoUrl;
 

crates/api_clients/fal_client/src/requests/webhook/image/text/enqueue_nano_banana_pro_text_to_image_webhook.rs

@@ -1,7 +1,7 @@
 use crate::creds::fal_api_key::FalApiKey;
 use crate::error::classify_fal_error::classify_fal_error;
 use crate::error::fal_error_plus::FalErrorPlus;
-use fal::endpoints::fal_ai::nano_banana_pro::nano_banana_pro_text_to_image::{nano_banana_pro_text_to_image, NanoBananaProTextToImageInput};
+use crate::requests::http::image::text::http_nano_banana_pro_text_to_image::{nano_banana_pro_text_to_image, NanoBananaProTextToImageInput};
 use fal::webhook::WebhookResponse;
 use reqwest::IntoUrl;
 use crate::requests::traits::fal_request_cost_calculator_trait::{FalRequestCostCalculator, UsdCents};