SwarmUIAPIBackends.cs

using SwarmUI.Accounts;
using SwarmUI.Core;
using SwarmUI.Utils;
using SwarmUI.WebAPI;
using Hartsy.Extensions.APIBackends.Backends;
using SwarmUI.Text2Image;
using Microsoft.AspNetCore.Html;
using Hartsy.Extensions.APIBackends.Models;

namespace Hartsy.Extensions.APIBackends;

/// <summary>Permissions for the APIBackends extension.</summary>
public static class APIBackendsPermissions
{
    public static readonly PermInfoGroup APIBackendsPermGroup = new("APIBackends", "Permissions related to API-based image generation backends.");
    public static readonly PermInfo PermUseOpenAI = Permissions.Register(new("use_openai", "Use OpenAI APIs", "Allows using OpenAI's DALL-E models for image generation.", PermissionDefault.POWERUSERS, APIBackendsPermGroup));
    public static readonly PermInfo PermUseIdeogram = Permissions.Register(new("use_ideogram", "Use Ideogram API", "Allows using Ideogram's API for image generation.", PermissionDefault.POWERUSERS, APIBackendsPermGroup));
    public static readonly PermInfo PermUseBlackForest = Permissions.Register(new("use_blackforest", "Use Black Forest Labs API", "Allows using Black Forest Labs' Flux model APIs for image generation.", PermissionDefault.POWERUSERS, APIBackendsPermGroup));
    public static readonly PermInfo PermUseGrok = Permissions.Register(new("use_grok", "Use Grok API", "Allows using Grok's API for image generation.", PermissionDefault.POWERUSERS, APIBackendsPermGroup));
    public static readonly PermInfo PermUseGoogleImagen = Permissions.Register(new("use_google_api", "Use Google API", "Allows using Google's Gemini image generation models for image generation.", PermissionDefault.POWERUSERS, APIBackendsPermGroup));
    public static readonly PermInfo PermUseFal = Permissions.Register(new("use_fal_api", "Use Fal.ai API", "Allows using Fal.ai's 600+ models for image and video generation.", PermissionDefault.POWERUSERS, APIBackendsPermGroup));
    public static readonly PermInfo PermViewCapabilities = Permissions.Register(new("view_api_model_capabilities", "View API Model Capabilities", "Allows reading the API model capability map that drives parameter visibility.", PermissionDefault.GUEST, APIBackendsPermGroup));
}

/// <summary>Extension that adds support for various API-based image generation services.</summary>
public class SwarmUIAPIBackends : Extension
{
    public static T2IParamGroup OpenAIParamGroup;
    public static T2IParamGroup GPTImage1Group;
    public static T2IParamGroup GrokParamGroup;
    public static T2IParamGroup Grok2ImageGroup;
    public static T2IParamGroup GoogleParamGroup;
    public static T2IParamGroup GoogleImagenGroup;
    public static T2IParamGroup IdeogramParamGroup;
    public static T2IParamGroup IdeogramGeneralGroup;
    public static T2IParamGroup IdeogramAdvancedGroup;
    public static T2IParamGroup BlackForestGroup;
    public static T2IParamGroup BlackForestGeneralGroup;
    public static T2IParamGroup BlackForestAdvancedGroup;

    // OpenAI Parameters
    public static T2IRegisteredParam<string> SizeParam_GPTImage, SizeParam_GPTImage2;

    // GPT Image 1 Parameters
    public static T2IRegisteredParam<string> QualityParam_GPTImage1;
    public static T2IRegisteredParam<string> BackgroundParam_GPTImage1;
    public static T2IRegisteredParam<string> ModerationParam_GPTImage1;
    public static T2IRegisteredParam<string> OutputFormatParam_GPTImage1;
    public static T2IRegisteredParam<int> OutputCompressionParam_GPTImage1;

    // GPT Image 1.5 Parameter
    public static T2IRegisteredParam<string> QualityParam_GPTImage1_5 => QualityParam_GPTImage1;
    public static T2IRegisteredParam<string> BackgroundParam_GPTImage1_5 => BackgroundParam_GPTImage1;
    public static T2IRegisteredParam<string> ModerationParam_GPTImage1_5 => ModerationParam_GPTImage1;
    public static T2IRegisteredParam<string> OutputFormatParam_GPTImage1_5 => OutputFormatParam_GPTImage1;
    public static T2IRegisteredParam<int> OutputCompressionParam_GPTImage1_5 => OutputCompressionParam_GPTImage1;

    // Ideogram Parameters
    public static T2IRegisteredParam<string> StyleParam_Ideogram;
    public static T2IRegisteredParam<string> MagicPromptParam_Ideogram;
    public static T2IRegisteredParam<string> RenderingSpeedParam_Ideogram;

    public static T2IRegisteredParam<string> RenderingSpeedParam_IdeogramV4;
    public static T2IRegisteredParam<string> ResolutionParam_IdeogramV4;
    public static T2IRegisteredParam<bool> CopyrightDetectionParam_IdeogramV4;

    public static T2IRegisteredParam<string> ColorPaletteParam_Ideogram;
    public static T2IRegisteredParam<Image> ImagePromptParam_Ideogram;
    public static T2IRegisteredParam<Image> ImageMaskPromptParam_Ideogram;
    public static T2IRegisteredParam<string> AspectRatioParam_Ideogram;
    public static T2IRegisteredParam<string> StyleTypeParam_Ideogram => StyleParam_Ideogram;
    public static T2IRegisteredParam<string> NegativePromptParam_Ideogram => T2IParamTypes.NegativePrompt;
    public static T2IRegisteredParam<double> ImageWeightParam_Ideogram;
    public static T2IRegisteredParam<Image> InitImageParam_Ideogram => T2IParamTypes.InitImage;
    public static T2IRegisteredParam<Image> MaskImageParam_Ideogram => T2IParamTypes.MaskImage;

    // Black Forest Labs API Parameters
    public static T2IRegisteredParam<double> GuidanceParam_BlackForest;
    public static T2IRegisteredParam<int> SafetyParam_BlackForest;
    public static T2IRegisteredParam<bool> PromptEnhanceParam_BlackForest;
    public static T2IRegisteredParam<string> OutputFormatParam_BlackForest;
    public static T2IRegisteredParam<bool> RawModeParam_BlackForest;
    public static T2IRegisteredParam<double> ImagePromptStrengthParam_BlackForest;
    public static T2IRegisteredParam<int> WidthParam_BlackForest => T2IParamTypes.Width;
    public static T2IRegisteredParam<int> HeightParam_BlackForest => T2IParamTypes.Height;
    public static T2IRegisteredParam<string> AspectRatioParam_BlackForest => T2IParamTypes.AspectRatio;
    public static T2IRegisteredParam<bool> PromptUpsampling_BlackForest => PromptEnhanceParam_BlackForest;
    public static T2IRegisteredParam<int> SafetyTolerance_BlackForest => SafetyParam_BlackForest;
    public static T2IRegisteredParam<long> SeedParam_BlackForest => T2IParamTypes.Seed;
    public static T2IRegisteredParam<int> StepsParam_BlackForest => T2IParamTypes.Steps;

    // Grok Parameters
    public static T2IRegisteredParam<string> AspectRatioParam_Grok;
    public static T2IRegisteredParam<string> ResolutionParam_Grok;
    public static T2IRegisteredParam<Image> InitImageParam_Grok => T2IParamTypes.InitImage;

    // Google Parameters
    public static T2IRegisteredParam<string> AspectRatioParam_Google;
    public static T2IRegisteredParam<string> ImageSizeParam_GoogleGemini3;
    public static T2IRegisteredParam<Image> InitImageParam_Google => T2IParamTypes.InitImage;

    // Fal.ai Text-to-Image Parameters (standard models: FLUX dev/schnell/pro, SD, HiDream, Qwen, Sana, etc.)
    public static T2IRegisteredParam<string> ImageSizeParam_Fal;
    public static T2IRegisteredParam<long> SeedParam_Fal => T2IParamTypes.Seed;
    public static T2IRegisteredParam<double> GuidanceScaleParam_Fal => T2IParamTypes.CFGScale;
    public static T2IRegisteredParam<int> NumInferenceStepsParam_Fal => T2IParamTypes.Steps;
    public static T2IRegisteredParam<string> OutputFormatParam_Fal;
    public static T2IRegisteredParam<bool> SafetyCheckerParam_Fal;

    // Fal.ai Aspect Ratio Image Parameters (FLUX Ultra, Kling Image, Nano Banana)
    public static T2IRegisteredParam<string> AspectRatioParam_FalImage;
    public static T2IRegisteredParam<string> ResolutionParam_FalImage;
    public static T2IRegisteredParam<string> OutputFormatParam_FalAspect;

    // Fal.ai Negative Prompt — aliased to core NegativePrompt (same as SeedParam_Fal => T2IParamTypes.Seed)
    public static T2IRegisteredParam<string> NegativePromptParam_FalImage => T2IParamTypes.NegativePrompt;

    // Fal.ai Recraft Parameters
    public static T2IRegisteredParam<string> StyleParam_Recraft;

    // Fal.ai Image-to-Image / Edit Parameters — aliased to core InitImage
    public static T2IRegisteredParam<Image> ImagePromptParam_Fal => T2IParamTypes.InitImage;

    // Fal.ai Video Parameters (generic - used by models without specific params)
    public static T2IRegisteredParam<string> DurationParam_FalVideo;
    public static T2IRegisteredParam<string> AspectRatioParam_FalVideo;
    public static T2IRegisteredParam<string> ResolutionParam_FalVideo;
    public static T2IRegisteredParam<bool> GenerateAudioParam_FalVideo;
    public static T2IRegisteredParam<string> NegativePromptParam_FalVideo;

    // Kling-specific video parameters (duration: 3-15; aspect: 16:9,9:16,1:1; audio; negative; NO resolution)
    public static T2IRegisteredParam<string> DurationParam_Kling;
    public static T2IRegisteredParam<string> AspectRatioParam_Kling;
    public static T2IRegisteredParam<bool> GenerateAudioParam_Kling;
    public static T2IRegisteredParam<string> NegativePromptParam_Kling;

    // Veo-specific video parameters (duration: 4s,6s,8s; aspect: 16:9,9:16; resolution: 720p,1080p; audio; negative; seed)
    public static T2IRegisteredParam<string> DurationParam_Veo;
    public static T2IRegisteredParam<string> AspectRatioParam_Veo;
    public static T2IRegisteredParam<string> ResolutionParam_Veo;
    public static T2IRegisteredParam<bool> GenerateAudioParam_Veo;
    public static T2IRegisteredParam<string> NegativePromptParam_Veo;

    // Luma-specific video parameters (duration: 5s,9s; aspect: many; resolution: 540p,720p,1080p; NO audio/negative)
    public static T2IRegisteredParam<string> DurationParam_Luma;
    public static T2IRegisteredParam<string> AspectRatioParam_Luma;
    public static T2IRegisteredParam<string> ResolutionParam_Luma;

    // MiniMax-specific video parameters (duration: 6,10 only; NO aspect/resolution/audio/negative)
    public static T2IRegisteredParam<string> DurationParam_MiniMax;

    // Hunyuan-specific video parameters (NO duration; aspect: 16:9,9:16; resolution: 480p,580p,720p; seed)
    public static T2IRegisteredParam<string> AspectRatioParam_Hunyuan;
    public static T2IRegisteredParam<string> ResolutionParam_Hunyuan;

    // Seedance 2.0 video params (duration: auto/4-15; aspect: many incl auto; resolution: 480p/720p; audio; seed via SeedParam_Fal)
    public static T2IRegisteredParam<string> DurationParam_Seedance2;
    public static T2IRegisteredParam<string> AspectRatioParam_Seedance2;
    public static T2IRegisteredParam<string> ResolutionParam_Seedance2;
    public static T2IRegisteredParam<bool> GenerateAudioParam_Seedance2;

    // Seedance 1.0 video params (duration: 2-12; aspect: no auto; resolution: 480p/720p/1080p; camera_fixed)
    public static T2IRegisteredParam<string> DurationParam_Seedance1;
    public static T2IRegisteredParam<string> AspectRatioParam_Seedance1;
    public static T2IRegisteredParam<string> ResolutionParam_Seedance1;
    public static T2IRegisteredParam<bool> CameraFixedParam_Seedance1;

    // Per-family video enums. GetValues receives a Session, not the selected model, so a single shared param
    // cannot narrow its list per model - each family that has a distinct enum needs its own param.
    public static T2IRegisteredParam<string> DurationParam_Wan22, AspectRatioParam_Wan22, ResolutionParam_Wan22;
    public static T2IRegisteredParam<string> DurationParam_PixVerse, AspectRatioParam_PixVerse, ResolutionParam_PixVerse;
    public static T2IRegisteredParam<string> DurationParam_Ltx2;
    public static T2IRegisteredParam<string> DurationParam_Ltx13b, AspectRatioParam_Ltx13b, ResolutionParam_Ltx13b;
    public static T2IRegisteredParam<string> DurationParam_Vidu, AspectRatioParam_Vidu, ResolutionParam_Vidu;
    public static T2IRegisteredParam<string> DurationParam_Pika, AspectRatioParam_Pika, ResolutionParam_Pika;
    public static T2IRegisteredParam<string> DurationParam_Kandinsky, ResolutionParam_Kandinsky;

    // Wan 2.5/2.6/2.7. Duration and resolution enums differ per version, so each gets its own param.
    public static T2IRegisteredParam<string> DurationParam_Wan25, AspectRatioParam_Wan25, ResolutionParam_Wan25;
    public static T2IRegisteredParam<string> DurationParam_Wan26;
    public static T2IRegisteredParam<string> DurationParam_Wan27, AspectRatioParam_Wan27, DurationParam_Wan27Ref;
    public static T2IRegisteredParam<string> ResolutionParam_Wan2x;
    public static T2IRegisteredParam<string> AudioUrlParam_Wan;
    /// <summary>Shared by any i2v model that accepts a final frame (Wan 2.7, Seedance 2.5).</summary>
    public static T2IRegisteredParam<string> EndImageUrlParam;
    public static T2IRegisteredParam<string> DurationParam_Seedance25;
    public static T2IRegisteredParam<bool> PromptExpansionParam_Wan, MultiShotsParam_Wan;
    public static T2IRegisteredParam<string> DurationParam_KlingTurbo;

    // MiniMax H3. Its resolution scale (768P/2K/4K) matches nothing else in the extension.
    public static T2IRegisteredParam<string> DurationParam_H3, ResolutionParam_H3, AspectRatioParam_H3, AspectRatioParam_H3Ref;

    // FLUX 3 video. No seed input; safety tolerance replaces the usual negative prompt.
    public static T2IRegisteredParam<string> DurationParam_Flux3, ResolutionParam_Flux3, AspectRatioParam_Flux3;
    public static T2IRegisteredParam<int> SafetyToleranceParam_Flux3;
    /// <summary>BFL's direct API sizes video as hd/fhd rather than fal's 720p/1080p.</summary>
    public static T2IRegisteredParam<string> ResolutionParam_Flux3Bfl;

    // FLUX.2 image models: no batch, steps, guidance or negative prompt - just size plus safety.
    public static T2IRegisteredParam<int> SafetyToleranceParam_Flux2;
    /// <summary>FLUX.2 edit endpoints accept an 'auto' size that the text-to-image ones do not.</summary>
    public static T2IRegisteredParam<string> ImageSizeParam_Flux2Edit;
    // Nano Banana 2 extends the aspect list to extreme ratios and starts resolution at 0.5K.
    public static T2IRegisteredParam<string> AspectRatioParam_NB2, ResolutionParam_NB2, ThinkingLevelParam_NB2, SystemPromptParam_NB2;
    public static T2IRegisteredParam<int> SafetyToleranceParam_NB2;
    public static T2IRegisteredParam<bool> WebSearchParam_NB2;

    // Fal utility params (upscalers, background removal, face restoration)
    public static T2IRegisteredParam<double> UpscaleFactorParam_FalUtility;
    public static T2IRegisteredParam<string> VideoUrlParam_FalUtility;

    // Reference URLs, shared by every multi-reference model (Seedance, Wan 2.7, MiniMax H3).
    // The field names each endpoint expects differ, so the builders map these to the right keys.
    public static T2IRegisteredParam<string> RefImageUrlsParam;
    public static T2IRegisteredParam<string> RefVideoUrlsParam;
    public static T2IRegisteredParam<string> RefAudioUrlsParam;

    public override void OnPreInit()
    {
        ScriptFiles.Add("Assets/api-backends.js");
    }

    public override void OnInit()
    {
        OpenAIParamGroup = new("OpenAI API", Toggles: false, Open: true, OrderPriority: 10);
        GPTImage1Group = new("GPT Image 1 Settings", Toggles: false, Open: true, OrderPriority: 12, Description: "Able to generate images with stronger instruction following, contextual awareness, and world knowledge.");

        IdeogramParamGroup = new("Ideogram API", Toggles: false, Open: true, OrderPriority: 20);
        IdeogramGeneralGroup = new("Ideogram Basic Settings", Toggles: false, Open: true, OrderPriority: 20, Description: "Core parameters for Ideogram image generation.");
        IdeogramAdvancedGroup = new("Ideogram Advanced Settings", Toggles: true, Open: false, OrderPriority: 21, Description: "Additional options for fine-tuning Ideogram generations.");

        GrokParamGroup = new("Grok API", Toggles: false, Open: true, OrderPriority: 30, Description: "API access to Grok's image generation models.");
        Grok2ImageGroup = new("Grok Image Settings", Toggles: false, Open: true, OrderPriority: 37, Description: "Parameters for Grok image generation and editing.");

        GoogleParamGroup = new("Google API", Toggles: false, Open: true, OrderPriority: 35, Description: "API access to Google's image generation models.");
        GoogleImagenGroup = new("Google Image Settings", Toggles: false, Open: true, OrderPriority: 35, Description: "Parameters for Google Gemini image generation.");

        BlackForestGroup = new("Black Forest Labs API", Toggles: false, Open: true, OrderPriority: 40, Description: "API access to Black Forest Labs' high quality Flux image generation models.");
        BlackForestGeneralGroup = new("Flux Core Settings", Toggles: false, Open: true, OrderPriority: 40, Description: "Core parameters for Flux image generation.\nFlux models excel at high-quality image generation with strong artistic control.");
        BlackForestAdvancedGroup = new("Flux Advanced Settings", Toggles: true, Open: false, OrderPriority: 41, Description: "Additional options for fine-tuning Flux generations and output processing.");

        // Each GPT Image model family has its own size list.
        SizeParam_GPTImage = T2IParamTypes.Register<string>(new("GPT Image Output Resolution",
            "Dimensions of the generated image.", "auto",
            GetValues: _ => ["auto///Auto (Recommended)", "1024x1024///Square", "1536x1024///Landscape", "1024x1536///Portrait"],
            OrderPriority: -10, Group: T2IParamTypes.GroupResolution, FeatureFlag: "gpt_image_params"));

        SizeParam_GPTImage2 = T2IParamTypes.Register<string>(new("GPT Image Two Output Resolution",
            "Dimensions of the generated image. GPT Image 2 reaches 2K; edges must be multiples of 16.", "auto",
            GetValues: _ => ["auto///Auto (Recommended)", "1024x1024///Square (1K)", "1536x1024///Landscape (1.5K)", "1024x1536///Portrait (1.5K)", "2048x2048///Square (2K)", "2048x1152///Wide Landscape (2K)", "1152x2048///Tall Portrait (2K)"],
            OrderPriority: -10, Group: T2IParamTypes.GroupResolution, FeatureFlag: "gpt-image-2_params"));

        // gpt-image-1 parameters
        QualityParam_GPTImage1 = T2IParamTypes.Register<string>(new("Quality",
            "Controls the quality of the generated image.\n" +
            "'Auto' - Automatically selects the best quality for the given model\n" +
            "'High' - Highest quality with maximum detail and clarity\n" +
            "'Medium' - Balanced quality suitable for most uses\n" +
            "'Low' - Faster generation with reduced quality\n" +
            "Higher quality levels may increase generation time and cost.",
            "auto", GetValues: _ => ["auto///Auto (Recommended)", "high///High Quality", "medium///Medium Quality", "low///Low Quality"],
            OrderPriority: -8, Group: GPTImage1Group, FeatureFlag: "gpt_image_params"));

        BackgroundParam_GPTImage1 = T2IParamTypes.Register<string>(new("Background",
            "Controls the background transparency of the generated image.\n" +
            "'Auto' - Automatically determines the best background for the image\n" +
            "'Transparent' - Creates a transparent background (requires PNG or WebP format)\n" +
            "'Opaque' - Creates a solid background with no transparency\n" +
            "Note: Transparent backgrounds require PNG or WebP output format.",
            "auto", GetValues: _ => ["auto///Auto (Recommended)", "transparent///Transparent", "opaque///Opaque"],
            OrderPriority: -7, Group: GPTImage1Group, FeatureFlag: "gpt_image_params"));

        ModerationParam_GPTImage1 = T2IParamTypes.Register<string>(new("Content Moderation",
            "Controls the content moderation level for generated images.\n" +
            "'Auto' - Uses default moderation settings\n" +
            "'Low' - Less restrictive content filtering (use with caution)\n" +
            "Auto setting provides balanced content safety.",
            "auto", GetValues: _ => ["auto///Auto (Recommended)", "low///Low Filtering"],
            OrderPriority: -6, Group: GPTImage1Group, FeatureFlag: "gpt_image_params"));

        OutputFormatParam_GPTImage1 = T2IParamTypes.Register<string>(new("Image Output Format",
            "The format for the generated image.\n" +
            "'PNG' - Lossless format, supports transparency\n" +
            "'JPEG' - Compressed format, smaller file size\n" +
            "'WebP' - Modern format, good compression and transparency support\n" +
            "PNG is recommended for images with transparency.",
            "png", GetValues: _ => ["png///PNG (Lossless)", "jpeg///JPEG (Compressed)", "webp///WebP (Modern)"],
            OrderPriority: -5, Group: GPTImage1Group, FeatureFlag: "gpt_image_params"));

        OutputCompressionParam_GPTImage1 = T2IParamTypes.Register<int>(new("Output Compression",
            "The compression level (0-100%) for JPEG and WebP formats.\n" +
            "Higher values mean better quality but larger file sizes.\n" +
            "Only applies to JPEG and WebP output formats.\n" +
            "Default is 100% (maximum quality).",
            "100", Min: 0, Max: 100, ViewType: ParamViewType.SLIDER,
            OrderPriority: -4, Group: GPTImage1Group, FeatureFlag: "gpt_image_params"));

        // Ideogram Parameters
        StyleParam_Ideogram = T2IParamTypes.Register<string>(new("Generation Style",
            "Determines the artistic approach for image creation (V2+ models only):\n" +
            "'Auto' - Automatically selects style based on prompt\n" +
            "'General' - Balanced style suitable for most prompts\n" +
            "'Realistic' - Photorealistic style with natural lighting and details\n" +
            "'Design' - Clean, graphic design aesthetic\n" +
            "'Render_3D' - 3D rendered style with depth and lighting\n" +
            "'Anime' - Anime/manga inspired artistic style",
            "AUTO",
            GetValues: _ => ["AUTO///Auto (Recommended)", "GENERAL///General Purpose",
                "REALISTIC///Photorealistic", "DESIGN///Graphic Design",
                "RENDER_3D///3D Rendered", "ANIME///Anime Style"],
            OrderPriority: -10, Group: IdeogramGeneralGroup, FeatureFlag: "ideogram_style"
            ));

        AspectRatioParam_Ideogram = T2IParamTypes.Register<string>(new("Ideogram Aspect Ratio",
            "Sets the desired aspect ratio for the generated image.",
            "1:1", GetValues: _ => ["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3"],
            OrderPriority: -9, Group: IdeogramGeneralGroup, FeatureFlag: "ideogram_api"));

        // Advanced Parameters
        MagicPromptParam_Ideogram = T2IParamTypes.Register<string>(new("Magic Prompt Enhancement",
            "Controls Ideogram's prompt optimization system:\n" +
            "'Auto' - Let the system decide when to enhance prompts\n" +
            "'On' - Always enhance prompts for better results\n" +
            "'Off' - Use exact prompts without enhancement\n" +
            "Magic Prompt can help improve results but may deviate from exact prompt wording.", "AUTO",
            GetValues: _ => ["AUTO///Auto (Recommended)", "ON///Always Enhance", "OFF///Exact Prompts"],
            OrderPriority: -7, Group: IdeogramAdvancedGroup, FeatureFlag: "ideogram_api"));

        RenderingSpeedParam_Ideogram = T2IParamTypes.Register<string>(new("Rendering Speed",
            "Controls the rendering speed for V3 generation:\n" +
            "'Default' - Standard quality rendering\n" +
            "'Turbo' - Faster generation with slightly reduced quality",
            "DEFAULT", GetValues: _ => ["DEFAULT///Default (Standard Quality)", "TURBO///Turbo (Faster)"],
            OrderPriority: -6, Group: IdeogramAdvancedGroup, FeatureFlag: "ideogram_v3_params"));

        // Flash is not yet supported by the API (check docs) 
        RenderingSpeedParam_IdeogramV4 = T2IParamTypes.Register<string>(new("Ideogram V4 Rendering Speed",
            "Controls the speed/quality tradeoff for Ideogram V4 generation:\n" +
            "'Turbo' - Fastest generation\n" +
            "'Default' - Standard balance of speed and quality\n" +
            "'Quality' - Highest quality, slower generation",
            "DEFAULT", GetValues: _ => ["TURBO///Turbo (Faster)", "DEFAULT///Default (Balanced)", "QUALITY///Quality (Best)"],
            OrderPriority: -9, Group: IdeogramGeneralGroup, FeatureFlag: "ideogram_v4_params"));

        ResolutionParam_IdeogramV4 = T2IParamTypes.Register<string>(new("Ideogram VFour Resolution",
            "Output resolution for Ideogram V4.", "1024x1024",
            GetValues: _ => ["1024x1024///Square", "1280x720///Landscape", "720x1280///Portrait", "1536x512///Wide", "512x1536///Tall"],
            OrderPriority: -8, Group: T2IParamTypes.GroupResolution, FeatureFlag: "ideogram_v4_params"));

        CopyrightDetectionParam_IdeogramV4 = T2IParamTypes.Register<bool>(new("Ideogram Copyright Detection",
            "Ask Ideogram to flag potentially copyrighted content in the result.", "false",
            OrderPriority: -7, Group: IdeogramAdvancedGroup, FeatureFlag: "ideogram_v4_params"));

        ImageWeightParam_Ideogram = T2IParamTypes.Register<double>(new("Image Remix Weight",
            "Controls how strongly the input image influences the remixed generation (V3 only).\n" +
            "Lower values give more creative freedom, higher values stay closer to the original.",
            "0.5", Min: 0.0, Max: 1.0, Step: 0.05, ViewType: ParamViewType.SLIDER,
            OrderPriority: -1, Group: IdeogramAdvancedGroup, FeatureFlag: "ideogram_v3_params"));

        ColorPaletteParam_Ideogram = T2IParamTypes.Register<string>(new("Color Theme",
            "Apply a predefined color palette to influence image colors (V2+ models):\n" +
            "'None' - No color preference\n" +
            "'Ember' - Warm, fiery tones\n" +
            "'Fresh' - Bright, clean colors\n" +
            "'Jungle' - Natural, organic greens\n" +
            "'Magic' - Mystical purples and blues\n" +
            "'Melon' - Sweet pastels\n" +
            "'Mosaic' - Vibrant mix\n" +
            "'Pastel' - Soft, muted tones\n" +
            "'Ultramarine' - Ocean blues", "None",
            GetValues: _ => [
                "None///No Color Theme",
                "EMBER///Ember - Warm Tones",
                "FRESH///Fresh - Bright & Clean",
                "JUNGLE///Jungle - Natural Greens",
                "MAGIC///Magic - Mystical",
                "MELON///Melon - Sweet Pastels",
                "MOSAIC///Mosaic - Vibrant Mix",
                "PASTEL///Pastel - Soft Tones",
                "ULTRAMARINE///Ultramarine - Ocean Blues"
            ],
            OrderPriority: -3, Group: IdeogramGeneralGroup, FeatureFlag: "ideogram_style"));

        // Black Forest Labs API Parameters
        GuidanceParam_BlackForest = T2IParamTypes.Register<double>(new("Prompt Guidance",
            "Controls how strictly the generation follows the prompt (Flux Dev and Flux 2 Flex).\n" +
            "Default 3.0 for balanced results.\n" +
            "Lower values (1.5-2.5): More creative but less controlled\n" +
            "Higher values (3.0-5.0): Stricter prompt following but may reduce realism.", "3.0",
            Min: 1.5, Max: 5.0, Step: 0.1, ViewType: ParamViewType.SLIDER, OrderPriority: -6,
            Group: BlackForestGeneralGroup, FeatureFlag: "flux_dev_params"));

        SafetyParam_BlackForest = T2IParamTypes.Register<int>(new("Safety Filter Level",
            "Controls content filtering strictness for both input and output.\n" +
            "0: Most restrictive - blocks most potentially unsafe content\n" +
            "6: Least restrictive - allows most content through\n" +
            "Default 2 provides balanced filtering suitable for most use cases.", "2", Min: 0, Max: 6,
            ViewType: ParamViewType.SLIDER, OrderPriority: -5, Group: BlackForestGeneralGroup, FeatureFlag: "bfl_api"));

        PromptEnhanceParam_BlackForest = T2IParamTypes.Register<bool>(new("Prompt Enhancement",
            "Enables Flux's automatic prompt enhancement system.\n" +
            "When enabled: Automatically expands prompts with additional details\n" +
            "Can help achieve more artistic results but may reduce prompt precision\n" +
            "Recommended for creative/artistic work, disable for exact prompt following.\n" +
            "Supported by: Flux Dev, Flux Pro 1.1, Flux Ultra, Kontext Pro, Kontext Max.", "false",
            OrderPriority: -4, Group: BlackForestAdvancedGroup, FeatureFlag: "bfl_prompt_enhance"));

        RawModeParam_BlackForest = T2IParamTypes.Register<bool>(new("Raw Mode",
            "Enables raw generation mode in Flux Pro 1.1.\n" +
            "When enabled: Generates less processed, more natural-looking images\n" +
            "Raw mode can produce more authentic results but may be less polished\n" +
            "Only available in Flux Pro 1.1 ultra mode.", "false", OrderPriority: -3,
            Group: BlackForestAdvancedGroup, FeatureFlag: "flux_ultra_params"));

        ImagePromptStrengthParam_BlackForest = T2IParamTypes.Register<double>(new("Image Prompt Strength",
            "Controls how much the Init Image influences the generation.\n" +
            "0.0: Ignore image prompt completely\n" +
            "1.0: Follow image prompt very closely\n" +
            "Default 0.1 provides subtle guidance while allowing creativity.",
            "0.1", Min: 0.0, Max: 1.0, Step: 0.05, ViewType: ParamViewType.SLIDER,
            OrderPriority: -1, Group: BlackForestAdvancedGroup, FeatureFlag: "flux_ultra_params"));

        OutputFormatParam_BlackForest = T2IParamTypes.Register<string>(new("Output Format",
            "Choose the file format for saving generated images:\n" +
            "JPEG: Smaller files, slight quality loss, good for sharing\n" +
            "PNG: Lossless quality, larger files, best for editing.",
            "jpeg", GetValues: _ => ["jpeg///JPEG (Smaller)", "png///PNG (Lossless)"],
            OrderPriority: 0, Group: BlackForestAdvancedGroup, FeatureFlag: "bfl_api"));

        // Grok Parameters
        AspectRatioParam_Grok = T2IParamTypes.Register<string>(new("Grok Aspect Ratio",
            "Sets the aspect ratio for the generated image.\n" +
            "'Auto' lets the model choose the best ratio for your prompt.",
            "1:1", GetValues: _ => [
                "auto///Auto (Model Chooses)", "1:1///Square (1:1)",
                "16:9///Landscape (16:9)", "9:16///Portrait (9:16)",
                "4:3///Landscape (4:3)", "3:4///Portrait (3:4)",
                "3:2///Landscape (3:2)", "2:3///Portrait (2:3)",
                "2:1///Wide (2:1)", "1:2///Tall (1:2)",
                "21:9///Ultrawide (21:9)", "5:2///Wide Banner (5:2)"
            ],
            OrderPriority: -10, Group: Grok2ImageGroup, FeatureFlag: "grok_2_image_params"));

        ResolutionParam_Grok = T2IParamTypes.Register<string>(new("Grok Output Resolution",
            "Controls the output resolution of the generated image.\n" +
            "'1k' - ~1024px on the longest side\n" +
            "'2k' - ~2048px on the longest side (higher quality, slower)",
            "1k", GetValues: _ => ["1k///1K (~1024px)", "2k///2K (~2048px)"],
            OrderPriority: -9, Group: Grok2ImageGroup, FeatureFlag: "grok_2_image_params"));

        // Google Parameters
        AspectRatioParam_Google = T2IParamTypes.Register<string>(new("Google Aspect Ratio",
            "Sets the aspect ratio for the generated image.",
            "1:1", GetValues: _ => ["1:1///Square (1:1)", "16:9///Landscape (16:9)", "9:16///Portrait (9:16)", "4:3///Landscape (4:3)", "3:4///Portrait (3:4)"],
            OrderPriority: -10, Group: GoogleImagenGroup, FeatureFlag: "google_api"));

        ImageSizeParam_GoogleGemini3 = T2IParamTypes.Register<string>(new("Gemini Image Resolution",
            "Controls the output resolution for Gemini 3 image models.\n" +
            "512: Nano Banana 2 (gemini-3.1-flash-image) only\n" +
            "1K (default): all Gemini 3 image models\n" +
            "2K, 4K: all except Nano Banana 2 Lite (1K only)\n" +
            "Higher resolutions produce more detailed images but cost more.\n" +
            "Must use uppercase 'K' (e.g. 1K, 2K, 4K).",
            "1K", GetValues: _ => [
                "512///512px (0.5K - Nano Banana 2 only)",
                "1K///1K (Standard, Default)",
                "2K///2K (High Quality)",
                "4K///4K (Ultra High Quality)"
            ],
            OrderPriority: -6, Group: GoogleImagenGroup, FeatureFlag: "google_gemini3_params"));

        // Fal.ai Text-to-Image Parameters
        ImageSizeParam_Fal = T2IParamTypes.Register<string>(new("Image Size",
            "Controls the dimensions of the generated image:\n" +
            "Square HD: 1024x1024 high definition\n" +
            "Square: 512x512 standard\n" +
            "Portrait: 768x1024 or 832x1216\n" +
            "Landscape: 1024x768 or 1216x832",
            "landscape_4_3", GetValues: _ => [
                "square_hd///Square HD (1024x1024)",
                "square///Square (512x512)",
                "portrait_4_3///Portrait 4:3",
                "portrait_16_9///Portrait 16:9",
                "landscape_4_3///Landscape 4:3",
                "landscape_16_9///Landscape 16:9"
            ],
            OrderPriority: -10, Group: T2IParamTypes.GroupResolution, FeatureFlag: "fal_img_size"));

        // GuidanceScaleParam_Fal => T2IParamTypes.CFGScale (aliased, no registration needed)
        // NumInferenceStepsParam_Fal => T2IParamTypes.Steps (aliased, no registration needed)

        SafetyCheckerParam_Fal = T2IParamTypes.Register<bool>(new("Safety Checker",
            "Enable or disable the NSFW safety checker.\n" +
            "When enabled, inappropriate content will be filtered.",
            "true",
            OrderPriority: -3, Group: T2IParamTypes.GroupSampling, FeatureFlag: "fal_img_common"));

        OutputFormatParam_Fal = T2IParamTypes.Register<string>(new("Output File Format",
            "Choose the file format for generated images:\n" +
            "JPEG: Smaller files, slight quality loss, good for sharing\n" +
            "PNG: Lossless quality, larger files, best for editing.",
            "jpeg", GetValues: _ => ["jpeg///JPEG (Smaller)", "png///PNG (Lossless)"],
            OrderPriority: -2, Group: T2IParamTypes.GroupSampling, FeatureFlag: "fal_img_common"));

        // Fal.ai Aspect Ratio Image Parameters (FLUX Ultra, Kling Image, Nano Banana)
        AspectRatioParam_FalImage = T2IParamTypes.Register<string>(new("Image Aspect Ratio",
            "Aspect ratio for models that use aspect ratio instead of image size.\n" +
            "16:9: Widescreen, 9:16: Portrait, 1:1: Square, etc.",
            "16:9", GetValues: _ => [
                "auto///Auto (model decides)",
                "21:9///Ultrawide (21:9)",
                "16:9///Widescreen (16:9)",
                "3:2///Standard (3:2)",
                "4:3///Classic (4:3)",
                "5:4///Photo (5:4)",
                "1:1///Square (1:1)",
                "4:5///Portrait Photo (4:5)",
                "3:4///Portrait Classic (3:4)",
                "2:3///Portrait Standard (2:3)",
                "9:16///Portrait (9:16)",
                "9:21///Tall (9:21)"
            ],
            OrderPriority: -10, Group: T2IParamTypes.GroupResolution, FeatureFlag: "fal_aspect_image"));

        ResolutionParam_FalImage = T2IParamTypes.Register<string>(new("Image Resolution",
            "Resolution quality for the generated image.\n" +
            "1K: Standard, 2K: High-res, 4K: Ultra high-res (some models only).",
            "1K", GetValues: _ => [
                "1K///1K (Standard)",
                "2K///2K (High-res)",
                "4K///4K (Ultra, some models)"
            ],
            OrderPriority: -9, Group: T2IParamTypes.GroupResolution, FeatureFlag: "fal_resolution_image"));

        OutputFormatParam_FalAspect = T2IParamTypes.Register<string>(new("Fal Image Output Format",
            "Choose the file format for generated images.",
            "png", GetValues: _ => ["jpeg///JPEG", "png///PNG", "webp///WebP"],
            OrderPriority: -2, Group: T2IParamTypes.GroupSampling, FeatureFlag: "fal_aspect_image"));

        // Fal.ai Recraft Parameters
        StyleParam_Recraft = T2IParamTypes.Register<string>(new("Recraft Style",
            "The visual style for Recraft V3 image generation.\n" +
            "Choose a base style category. Sub-styles available via API.",
            "realistic_image", GetValues: _ => [
                "any///Any Style",
                "realistic_image///Realistic Image",
                "realistic_image/b_and_w///Realistic B&W",
                "realistic_image/hdr///Realistic HDR",
                "realistic_image/natural_light///Natural Light",
                "realistic_image/studio_portrait///Studio Portrait",
                "digital_illustration///Digital Illustration",
                "digital_illustration/pixel_art///Pixel Art",
                "digital_illustration/hand_drawn///Hand Drawn",
                "digital_illustration/2d_art_poster///2D Art Poster",
                "digital_illustration/handmade_3d///Handmade 3D",
                "digital_illustration/pop_art///Pop Art",
                "digital_illustration/noir///Noir",
                "vector_illustration///Vector Illustration",
                "vector_illustration/line_art///Line Art",
                "vector_illustration/bold_stroke///Bold Stroke",
                "vector_illustration/flat///Emotional Flat",
                "vector_illustration/linocut///Linocut"
            ],
            OrderPriority: -8, Group: T2IParamTypes.GroupSampling, FeatureFlag: "fal_recraft_params"));

        // ImagePromptParam_Fal => T2IParamTypes.InitImage (aliased, no registration needed)

        // Fal.ai Video Parameters
        // Grok Imagine Video keeps the original general-purpose set.
        DurationParam_FalVideo = T2IParamTypes.Register<string>(new("Video Duration",
            "Length of the generated video in seconds.",
            "5", GetValues: _ => ["3///3 seconds", "4///4 seconds", "5///5 seconds (Default)", "6///6 seconds", "8///8 seconds", "10///10 seconds"],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_video_params"));

        AspectRatioParam_FalVideo = T2IParamTypes.Register<string>(new("Video Aspect Ratio",
            "Aspect ratio for the generated video.",
            "16:9", GetValues: _ => ["16:9///Widescreen (16:9)", "9:16///Portrait (9:16)", "1:1///Square (1:1)"],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_video_params"));

        ResolutionParam_FalVideo = T2IParamTypes.Register<string>(new("Video Output Resolution",
            "Resolution of the generated video.",
            "720p", GetValues: _ => ["480p///480p (Fast)", "720p///720p (Standard)", "1080p///1080p (HD)"],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_video_params"));

        // Audio and negative prompt carry no per-model enum, so they stay shared and are gated on their own
        // capability flags - only models whose fal schema actually accepts them will show them.
        GenerateAudioParam_FalVideo = T2IParamTypes.Register<bool>(new("Generate Audio",
            "Generate audio alongside the video.\n" +
            "Only shown for models that actually support it.",
            "true",
            OrderPriority: -7, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_video_audio"));

        NegativePromptParam_FalVideo = T2IParamTypes.Register<string>(new("Video Negative Prompt",
            "Describe what you don't want in the generated video.",
            "", OrderPriority: -5, Group: T2IParamTypes.GroupAdvancedVideo, FeatureFlag: "fal_video_negative"));

        // ===== PER-FAMILY VIDEO ENUMS =====
        // Each fal model line accepts a different enum. GetValues cannot see the selected model (it takes a
        // Session), so narrowing has to be done with one param per family - otherwise users can pick a value
        // the model rejects with a 422 (Wan 2.2 caps at 720p, Kandinsky uses 512P/1024P, etc).
        DurationParam_Wan22 = T2IParamTypes.Register<string>(new("Wan Video Duration",
            "Length of the generated video. Wan 2.2 has no duration field, so this is sent as a frame count at 16fps.",
            "5", GetValues: _ => ["1///1 second", "2///2 seconds", "3///3 seconds", "5///5 seconds (Default)", "8///8 seconds", "10///10 seconds"],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_wan22_params"));

        AspectRatioParam_Wan22 = T2IParamTypes.Register<string>(new("Wan Video Aspect Ratio",
            "Aspect ratio for Wan 2.2.", "16:9",
            GetValues: _ => ["16:9///Widescreen (16:9)", "9:16///Portrait (9:16)", "1:1///Square (1:1)"],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_wan22_params"));

        ResolutionParam_Wan22 = T2IParamTypes.Register<string>(new("Wan Video Resolution",
            "Resolution for Wan 2.2. This model tops out at 720p.", "720p",
            GetValues: _ => ["480p///480p (Fast)", "580p///580p", "720p///720p (Max)"],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_wan22_params"));

        DurationParam_PixVerse = T2IParamTypes.Register<string>(new("PixVerse Video Duration",
            "Length of the generated video. PixVerse v5 supports 5 or 8 seconds.", "5",
            GetValues: _ => ["5///5 seconds", "8///8 seconds"],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_pixverse_params"));

        AspectRatioParam_PixVerse = T2IParamTypes.Register<string>(new("PixVerse Video Aspect Ratio",
            "Aspect ratio for PixVerse v5.", "16:9",
            GetValues: _ => ["16:9///Widescreen (16:9)", "4:3///Standard (4:3)", "1:1///Square (1:1)", "3:4///Portrait (3:4)", "9:16///Portrait (9:16)"],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_pixverse_params"));

        ResolutionParam_PixVerse = T2IParamTypes.Register<string>(new("PixVerse Video Resolution",
            "Resolution for PixVerse v5.", "720p",
            GetValues: _ => ["360p///360p", "540p///540p", "720p///720p (Standard)", "1080p///1080p (HD)"],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_pixverse_params"));

        DurationParam_Ltx2 = T2IParamTypes.Register<string>(new("LTX-2 Video Duration",
            "Length of the generated video. Sent as a frame count at 25fps.", "5",
            GetValues: _ => ["3///3 seconds", "5///5 seconds (Default)", "8///8 seconds", "10///10 seconds"],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_ltx2_params"));

        DurationParam_Ltx13b = T2IParamTypes.Register<string>(new("LTX-13B Video Duration",
            "Length of the generated video. Sent as a frame count at 24fps.", "5",
            GetValues: _ => ["3///3 seconds", "5///5 seconds (Default)", "8///8 seconds", "10///10 seconds"],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_ltx13b_params"));

        AspectRatioParam_Ltx13b = T2IParamTypes.Register<string>(new("LTX-13B Video Aspect Ratio",
            "Aspect ratio for LTX-13B distilled.", "auto",
            GetValues: _ => ["auto///Auto", "16:9///Widescreen (16:9)", "9:16///Portrait (9:16)", "1:1///Square (1:1)"],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_ltx13b_params"));

        ResolutionParam_Ltx13b = T2IParamTypes.Register<string>(new("LTX-13B Video Resolution",
            "Resolution for LTX-13B distilled. This model tops out at 720p.", "720p",
            GetValues: _ => ["480p///480p (Fast)", "720p///720p (Max)"],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_ltx13b_params"));

        DurationParam_Vidu = T2IParamTypes.Register<string>(new("Vidu Video Duration",
            "Length of the generated video in seconds.", "5",
            GetValues: _ => ["3///3 seconds", "5///5 seconds (Default)", "8///8 seconds", "10///10 seconds"],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_vidu_params"));

        AspectRatioParam_Vidu = T2IParamTypes.Register<string>(new("Vidu Video Aspect Ratio",
            "Aspect ratio for Vidu Q3.", "16:9",
            GetValues: _ => ["16:9///Widescreen (16:9)", "9:16///Portrait (9:16)", "4:3///Standard (4:3)", "3:4///Portrait (3:4)", "1:1///Square (1:1)"],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_vidu_params"));

        ResolutionParam_Vidu = T2IParamTypes.Register<string>(new("Vidu Video Resolution",
            "Resolution for Vidu Q3.", "720p",
            GetValues: _ => ["360p///360p", "540p///540p", "720p///720p (Standard)", "1080p///1080p (HD)"],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_vidu_params"));

        DurationParam_Pika = T2IParamTypes.Register<string>(new("Pika Video Duration",
            "Length of the generated video. Pika v2.2 supports 5 or 10 seconds.", "5",
            GetValues: _ => ["5///5 seconds", "10///10 seconds"],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_pika_params"));

        AspectRatioParam_Pika = T2IParamTypes.Register<string>(new("Pika Video Aspect Ratio",
            "Aspect ratio for Pika v2.2.", "16:9",
            GetValues: _ => ["16:9///Widescreen (16:9)", "9:16///Portrait (9:16)", "1:1///Square (1:1)", "4:5///Portrait (4:5)", "5:4///Landscape (5:4)", "3:2///Landscape (3:2)", "2:3///Portrait (2:3)"],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_pika_params"));

        ResolutionParam_Pika = T2IParamTypes.Register<string>(new("Pika Video Resolution",
            "Resolution for Pika v2.2.", "720p",
            GetValues: _ => ["720p///720p (Standard)", "1080p///1080p (HD)"],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_pika_params"));

        DurationParam_Kandinsky = T2IParamTypes.Register<string>(new("Kandinsky Video Duration",
            "Length of the generated video.", "5",
            GetValues: _ => ["5///5 seconds", "10///10 seconds"],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_kandinsky_params"));

        ResolutionParam_Kandinsky = T2IParamTypes.Register<string>(new("Kandinsky Video Resolution",
            "Resolution for Kandinsky 5 Pro. This model uses its own scale rather than 480p/720p.", "512P",
            GetValues: _ => ["512P///512P", "1024P///1024P (High)"],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_kandinsky_params"));

        // ===== KLING-SPECIFIC PARAMETERS =====
        DurationParam_Kling = T2IParamTypes.Register<string>(new("Kling Video Duration",
            "Length of the generated video in seconds.\n" +
            "Kling supports 3-15 second videos.",
            "5", GetValues: _ => [
                "3///3 seconds",
                "4///4 seconds",
                "5///5 seconds (Default)",
                "6///6 seconds",
                "7///7 seconds",
                "8///8 seconds",
                "9///9 seconds",
                "10///10 seconds",
                "11///11 seconds",
                "12///12 seconds",
                "13///13 seconds",
                "14///14 seconds",
                "15///15 seconds"
            ],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_kling_video_params"));

        AspectRatioParam_Kling = T2IParamTypes.Register<string>(new("Kling Video Aspect Ratio",
            "Aspect ratio for the generated video.\n" +
            "Kling supports 16:9, 9:16, and 1:1.",
            "16:9", GetValues: _ => [
                "16:9///Widescreen (16:9)",
                "9:16///Portrait (9:16)",
                "1:1///Square (1:1)"
            ],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_kling_video_params"));

        GenerateAudioParam_Kling = T2IParamTypes.Register<bool>(new("Kling Generate Audio",
            "Generate audio alongside the video.\n" +
            "Kling supports native audio generation in Chinese and English.",
            "true",
            OrderPriority: -7, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_kling_video_params"));

        NegativePromptParam_Kling = T2IParamTypes.Register<string>(new("Kling Negative Prompt",
            "Describe what you don't want in the generated video.\n" +
            "Default: blur, distort, and low quality",
            "", OrderPriority: -5, Group: T2IParamTypes.GroupAdvancedVideo, FeatureFlag: "fal_kling_video_params"));

        // ===== VEO-SPECIFIC PARAMETERS =====
        DurationParam_Veo = T2IParamTypes.Register<string>(new("Veo Video Duration",
            "Length of the generated video.\n" +
            "Veo supports 4, 6, or 8 second videos.",
            "8s", GetValues: _ => [
                "4s///4 seconds",
                "6s///6 seconds",
                "8s///8 seconds (Default)"
            ],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_veo_video_params"));

        AspectRatioParam_Veo = T2IParamTypes.Register<string>(new("Veo Video Aspect Ratio",
            "Aspect ratio for the generated video.\n" +
            "Veo supports 16:9 and 9:16.",
            "16:9", GetValues: _ => [
                "16:9///Widescreen (16:9)",
                "9:16///Portrait (9:16)"
            ],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_veo_video_params"));

        ResolutionParam_Veo = T2IParamTypes.Register<string>(new("Veo Video Resolution",
            "Resolution of the generated video.\n" +
            "Veo supports 720p and 1080p.",
            "720p", GetValues: _ => [
                "720p///720p (Standard)",
                "1080p///1080p (HD)"
            ],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_veo_video_params"));

        GenerateAudioParam_Veo = T2IParamTypes.Register<bool>(new("Veo Generate Audio",
            "Generate audio alongside the video.\n" +
            "Veo 3 supports native audio generation.",
            "true",
            OrderPriority: -7, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_veo_video_params"));

        NegativePromptParam_Veo = T2IParamTypes.Register<string>(new("Veo Negative Prompt",
            "Describe what you don't want in the generated video.",
            "", OrderPriority: -5, Group: T2IParamTypes.GroupAdvancedVideo, FeatureFlag: "fal_veo_video_params"));

        // ===== LUMA-SPECIFIC PARAMETERS =====
        DurationParam_Luma = T2IParamTypes.Register<string>(new("Luma Video Duration",
            "Length of the generated video.\n" +
            "Luma Ray 2 supports 5 or 9 second videos (9s costs 2x more).",
            "5s", GetValues: _ => [
                "5s///5 seconds",
                "9s///9 seconds (2x cost)"
            ],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_luma_video_params"));

        AspectRatioParam_Luma = T2IParamTypes.Register<string>(new("Luma Video Aspect Ratio",
            "Aspect ratio for the generated video.\n" +
            "Luma supports many aspect ratios.",
            "16:9", GetValues: _ => [
                "16:9///Widescreen (16:9)",
                "9:16///Portrait (9:16)",
                "4:3///Standard (4:3)",
                "3:4///Portrait (3:4)",
                "21:9///Ultrawide (21:9)",
                "9:21///Tall (9:21)"
            ],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_luma_video_params"));

        ResolutionParam_Luma = T2IParamTypes.Register<string>(new("Luma Video Resolution",
            "Resolution of the generated video.\n" +
            "720p costs 2x, 1080p costs 4x more than 540p.",
            "540p", GetValues: _ => [
                "540p///540p (Standard)",
                "720p///720p (2x cost)",
                "1080p///1080p (4x cost)"
            ],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_luma_video_params"));

        // ===== MINIMAX-SPECIFIC PARAMETERS =====
        DurationParam_MiniMax = T2IParamTypes.Register<string>(new("MiniMax Video Duration",
            "Length of the generated video.\n" +
            "MiniMax Hailuo supports 6 or 10 second videos.",
            "6", GetValues: _ => [
                "6///6 seconds",
                "10///10 seconds"
            ],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_minimax_video_params"));

        // ===== HUNYUAN-SPECIFIC PARAMETERS =====
        AspectRatioParam_Hunyuan = T2IParamTypes.Register<string>(new("Hunyuan Video Aspect Ratio",
            "Aspect ratio for the generated video.\n" +
            "Hunyuan supports 16:9 and 9:16.",
            "16:9", GetValues: _ => [
                "16:9///Widescreen (16:9)",
                "9:16///Portrait (9:16)"
            ],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_hunyuan_video_params"));

        ResolutionParam_Hunyuan = T2IParamTypes.Register<string>(new("Hunyuan Video Resolution",
            "Resolution of the generated video.\n" +
            "Hunyuan supports 480p, 580p, and 720p.",
            "720p", GetValues: _ => [
                "480p///480p (Fast)",
                "580p///580p",
                "720p///720p (Standard)"
            ],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_hunyuan_video_params"));

        // ===== SEEDANCE 2.0-SPECIFIC PARAMETERS =====
        DurationParam_Seedance2 = T2IParamTypes.Register<string>(new("Seedance Two Video Duration",
            "Length of the generated video.\n" +
            "Seedance 2.0 supports auto or 4-15 second videos.",
            "auto", GetValues: _ => [
                "auto///Auto (Default)",
                "4///4 seconds",
                "5///5 seconds",
                "6///6 seconds",
                "7///7 seconds",
                "8///8 seconds",
                "9///9 seconds",
                "10///10 seconds",
                "11///11 seconds",
                "12///12 seconds",
                "13///13 seconds",
                "14///14 seconds",
                "15///15 seconds"
            ],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_seedance2_duration"));

        AspectRatioParam_Seedance2 = T2IParamTypes.Register<string>(new("Seedance Two Video Aspect Ratio",
            "Aspect ratio for the generated video.\n" +
            "Seedance 2.0 supports multiple aspect ratios including auto.",
            "auto", GetValues: _ => [
                "auto///Auto (Default)",
                "21:9///Ultra-wide (21:9)",
                "16:9///Widescreen (16:9)",
                "4:3///Standard (4:3)",
                "1:1///Square (1:1)",
                "3:4///Portrait (3:4)",
                "9:16///Tall Portrait (9:16)"
            ],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_seedance2_video_params"));

        ResolutionParam_Seedance2 = T2IParamTypes.Register<string>(new("Seedance Two Video Resolution",
            "Resolution of the generated video.\n" +
            "Seedance 2.0 supports 480p and 720p.",
            "720p", GetValues: _ => [
                "480p///480p (Fast)",
                "720p///720p (Default)"
            ],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_seedance2_video_params"));

        GenerateAudioParam_Seedance2 = T2IParamTypes.Register<bool>(new("Seedance Two Generate Audio",
            "Generate synchronized audio alongside the video.\n" +
            "Seedance 2.0 supports native audio generation including lip-synced speech.",
            "true",
            OrderPriority: -7, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_seedance2_video_params"));

        // ===== SEEDANCE 1.0-SPECIFIC PARAMETERS =====
        DurationParam_Seedance1 = T2IParamTypes.Register<string>(new("Seedance One Video Duration",
            "Length of the generated video in seconds.\n" +
            "Seedance 1.0 supports 2-12 second videos.",
            "5", GetValues: _ => [
                "2///2 seconds",
                "3///3 seconds",
                "4///4 seconds",
                "5///5 seconds (Default)",
                "6///6 seconds",
                "7///7 seconds",
                "8///8 seconds",
                "9///9 seconds",
                "10///10 seconds",
                "11///11 seconds",
                "12///12 seconds"
            ],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_seedance1_video_params"));

        AspectRatioParam_Seedance1 = T2IParamTypes.Register<string>(new("Seedance One Video Aspect Ratio",
            "Aspect ratio for the generated video.\n" +
            "Seedance 1.0 supports multiple aspect ratios.",
            "16:9", GetValues: _ => [
                "21:9///Ultra-wide (21:9)",
                "16:9///Widescreen (16:9, Default)",
                "4:3///Standard (4:3)",
                "1:1///Square (1:1)",
                "3:4///Portrait (3:4)",
                "9:16///Tall Portrait (9:16)"
            ],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_seedance1_video_params"));

        ResolutionParam_Seedance1 = T2IParamTypes.Register<string>(new("Seedance One Video Resolution",
            "Resolution of the generated video.\n" +
            "Seedance 1.0 supports 480p, 720p, and 1080p.",
            "1080p", GetValues: _ => [
                "480p///480p (Fast)",
                "720p///720p (Standard)",
                "1080p///1080p (HD, Default)"
            ],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_seedance1_video_params"));

        CameraFixedParam_Seedance1 = T2IParamTypes.Register<bool>(new("Seedance One Camera Fixed",
            "Whether to fix the camera position during video generation.\n" +
            "When enabled, the camera stays stationary.",
            "false",
            OrderPriority: -7, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_seedance1_video_params"));

        // ===== WAN 2.5 / 2.6 / 2.7 =====
        DurationParam_Wan25 = T2IParamTypes.Register<string>(new("Wan TwoFive Video Duration",
            "Length of the generated video. Wan 2.5 supports 5 or 10 seconds.", "5",
            GetValues: _ => ["5///5 seconds", "10///10 seconds"],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_wan25_params"));

        AspectRatioParam_Wan25 = T2IParamTypes.Register<string>(new("Wan TwoFive Video Aspect Ratio",
            "Aspect ratio for Wan 2.5.", "16:9",
            GetValues: _ => ["16:9///Widescreen (16:9)", "9:16///Portrait (9:16)", "1:1///Square (1:1)"],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_wan25_params"));

        ResolutionParam_Wan25 = T2IParamTypes.Register<string>(new("Wan TwoFive Video Resolution",
            "Resolution for Wan 2.5.", "720p",
            GetValues: _ => ["480p///480p (Fast)", "720p///720p (Standard)", "1080p///1080p (HD)"],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_wan25_params"));

        DurationParam_Wan26 = T2IParamTypes.Register<string>(new("Wan TwoSix Video Duration",
            "Length of the generated video. Wan 2.6 supports 5, 10 or 15 seconds.", "5",
            GetValues: _ => ["5///5 seconds", "10///10 seconds", "15///15 seconds"],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_wan26_params"));

        DurationParam_Wan27 = T2IParamTypes.Register<string>(new("Wan TwoSeven Video Duration",
            "Length of the generated video, 2 to 15 seconds.", "5",
            GetValues: _ => ["2///2 seconds", "3///3 seconds", "4///4 seconds", "5///5 seconds (Default)", "6///6 seconds", "7///7 seconds", "8///8 seconds", "9///9 seconds", "10///10 seconds", "11///11 seconds", "12///12 seconds", "13///13 seconds", "14///14 seconds", "15///15 seconds"],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_wan27_params"));

        DurationParam_Wan27Ref = T2IParamTypes.Register<string>(new("Wan TwoSeven Reference Video Duration",
            "Length of the generated video. Reference-to-video is capped at 10 seconds.", "5",
            GetValues: _ => ["2///2 seconds", "3///3 seconds", "4///4 seconds", "5///5 seconds (Default)", "6///6 seconds", "7///7 seconds", "8///8 seconds", "9///9 seconds", "10///10 seconds"],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_wan27ref_params"));

        AspectRatioParam_Wan27 = T2IParamTypes.Register<string>(new("Wan TwoSeven Video Aspect Ratio",
            "Aspect ratio for Wan 2.7. Not used by image-to-video, which follows the input image.", "16:9",
            GetValues: _ => ["16:9///Widescreen (16:9)", "9:16///Portrait (9:16)", "1:1///Square (1:1)", "4:3///Standard (4:3)", "3:4///Portrait (3:4)"],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_wan27_aspect"));

        ResolutionParam_Wan2x = T2IParamTypes.Register<string>(new("Wan TwoSixPlus Video Resolution",
            "Resolution for Wan 2.6 and 2.7. These versions start at 720p.", "720p",
            GetValues: _ => ["720p///720p (Standard)", "1080p///1080p (HD)"],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_wan2x_resolution"));

        AudioUrlParam_Wan = T2IParamTypes.Register<string>(new("Reference Audio URL",
            "Publicly accessible WAV or MP3 URL to drive the video's motion and timing.\n" +
            "3-30 seconds, up to 15 MB. Leave empty for a silent generation.",
            "", OrderPriority: -6, Group: T2IParamTypes.GroupAdvancedVideo, FeatureFlag: "fal_wan_audio"));

        EndImageUrlParam = T2IParamTypes.Register<string>(new("Last Frame Image URL",
            "Publicly accessible image URL to use as the final frame.\n" +
            "The model generates the motion between your Init Image and this one.",
            "", OrderPriority: -5, Group: T2IParamTypes.GroupAdvancedVideo, FeatureFlag: "fal_end_image_url"));

        PromptExpansionParam_Wan = T2IParamTypes.Register<bool>(new("Prompt Expansion",
            "Let the model rewrite your prompt for richer detail.\n" +
            "Disable for literal prompt following.", "true",
            OrderPriority: -4, Group: T2IParamTypes.GroupAdvancedVideo, FeatureFlag: "fal_prompt_expansion"));

        MultiShotsParam_Wan = T2IParamTypes.Register<bool>(new("Multi-Shot Segmentation",
            "Let the model split the video into multiple camera shots.\n" +
            "Only takes effect when Prompt Expansion is enabled.", "false",
            OrderPriority: -3, Group: T2IParamTypes.GroupAdvancedVideo, FeatureFlag: "fal_wan_multishot"));

        DurationParam_Seedance25 = T2IParamTypes.Register<string>(new("Seedance TwoFive Video Duration",
            "Length of the generated video. Seedance 2.5 runs up to 30 seconds in a single shot.", "auto",
            GetValues: _ => ["auto///Auto (Default)", .. Enumerable.Range(4, 27).Select(i => $"{i}///{i} seconds")],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_seedance25_params"));

        DurationParam_Flux3 = T2IParamTypes.Register<string>(new("FLUX Three Video Duration",
            "Length of the generated video. FLUX 3 runs any whole number of seconds from 5 to 20.", "auto",
            GetValues: _ => ["auto///Auto (Default)", .. Enumerable.Range(5, 16).Select(i => $"{i}///{i} seconds")],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_flux3_params"));

        AspectRatioParam_Flux3 = T2IParamTypes.Register<string>(new("FLUX Three Video Aspect Ratio",
            "Aspect ratio for FLUX 3.", "auto",
            GetValues: _ => ["auto///Auto (Default)", "21:9///Ultra-wide (21:9)", "2:1///Wide (2:1)", "16:9///Widescreen (16:9)", "4:3///Standard (4:3)", "1:1///Square (1:1)", "3:4///Portrait (3:4)", "9:16///Portrait (9:16)"],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_flux3_params"));

        ResolutionParam_Flux3 = T2IParamTypes.Register<string>(new("FLUX Three Video Resolution",
            "Resolution for FLUX 3.", "720p",
            GetValues: _ => ["720p///720p (Standard)", "1080p///1080p (HD)"],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_flux3_params"));

        SafetyToleranceParam_Flux3 = T2IParamTypes.Register<int>(new("FLUX Three Safety Tolerance",
            "Content filtering strictness. 0 is strictest, 4 is most permissive.", "2",
            Min: 0, Max: 4, ViewType: ParamViewType.SLIDER,
            OrderPriority: -6, Group: T2IParamTypes.GroupAdvancedVideo, FeatureFlag: "fal_flux3_params"));

        ImageSizeParam_Flux2Edit = T2IParamTypes.Register<string>(new("FLUX Two Edit Image Size",
            "Output size for FLUX.2 editing. 'Auto' keeps the input image's dimensions.", "auto",
            GetValues: _ => ["auto///Auto (Match Input)", "square_hd///Square HD", "square///Square", "portrait_4_3///Portrait 4:3", "portrait_16_9///Portrait 16:9", "landscape_4_3///Landscape 4:3", "landscape_16_9///Landscape 16:9"],
            OrderPriority: -10, Group: T2IParamTypes.GroupResolution, FeatureFlag: "fal_flux2_edit_params"));

        SafetyToleranceParam_Flux2 = T2IParamTypes.Register<int>(new("FLUX Two Safety Tolerance",
            "Content filtering strictness. 1 is most strict, 5 is most permissive.", "2",
            Min: 1, Max: 5, ViewType: ParamViewType.SLIDER,
            OrderPriority: -4, Group: T2IParamTypes.GroupSampling, FeatureFlag: "fal_flux2_params"));

        AspectRatioParam_NB2 = T2IParamTypes.Register<string>(new("Nano Banana Two Aspect Ratio",
            "Aspect ratio. Nano Banana 2 also accepts extreme banner and strip ratios.", "auto",
            GetValues: _ => ["auto///Auto (Default)", "21:9///Ultrawide (21:9)", "16:9///Widescreen (16:9)", "3:2///Standard (3:2)", "4:3///Classic (4:3)", "5:4///Photo (5:4)", "1:1///Square (1:1)", "4:5///Portrait (4:5)", "3:4///Portrait (3:4)", "2:3///Portrait (2:3)", "9:16///Portrait (9:16)", "4:1///Banner (4:1)", "1:4///Strip (1:4)", "8:1///Wide Banner (8:1)", "1:8///Tall Strip (1:8)"],
            OrderPriority: -10, Group: T2IParamTypes.GroupResolution, FeatureFlag: "fal_nb2_params"));

        ResolutionParam_NB2 = T2IParamTypes.Register<string>(new("Nano Banana Two Resolution",
            "Output resolution. Starts at 0.5K, unlike the other aspect-ratio models.", "1K",
            GetValues: _ => ["0.5K///0.5K (Fastest)", "1K///1K (Default)", "2K///2K", "4K///4K (Highest)"],
            OrderPriority: -9, Group: T2IParamTypes.GroupResolution, FeatureFlag: "fal_nb2_params"));

        SafetyToleranceParam_NB2 = T2IParamTypes.Register<int>(new("Nano Banana Two Safety Tolerance",
            "Content filtering strictness, 1 (most strict) to 6 (most permissive).", "4",
            Min: 1, Max: 6, ViewType: ParamViewType.SLIDER,
            OrderPriority: -5, Group: T2IParamTypes.GroupSampling, FeatureFlag: "fal_nb2_params"));

        ThinkingLevelParam_NB2 = T2IParamTypes.Register<string>(new("Nano Banana Two Thinking Level",
            "How much reasoning the model applies before generating.\n" +
            "'High' improves complex prompts and text rendering at the cost of speed.", "",
            GetValues: _ => ["///Model Default", "minimal///Minimal (Fastest)", "high///High (Best Quality)"],
            OrderPriority: -4, Group: T2IParamTypes.GroupSampling, FeatureFlag: "fal_nb2_params"));

        WebSearchParam_NB2 = T2IParamTypes.Register<bool>(new("Nano Banana Two Web Search",
            "Let the model search the web for reference while generating.", "false",
            OrderPriority: -3, Group: T2IParamTypes.GroupSampling, FeatureFlag: "fal_nb2_params"));

        SystemPromptParam_NB2 = T2IParamTypes.Register<string>(new("Nano Banana Two System Prompt",
            "Optional system-level instruction applied before your prompt.", "",
            OrderPriority: -2, Group: T2IParamTypes.GroupSampling, FeatureFlag: "fal_nb2_params"));

        ResolutionParam_Flux3Bfl = T2IParamTypes.Register<string>(new("FLUX Three Direct Video Resolution",
            "Resolution for FLUX 3 on Black Forest Labs' own API. Drafts are HD only.", "hd",
            GetValues: _ => ["hd///HD (720p)", "fhd///Full HD (1080p)", "qhd///2K", "uhd///4K"],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "bfl_flux3_params"));

        DurationParam_H3 = T2IParamTypes.Register<string>(new("MiniMax HThree Video Duration",
            "Length of the generated video in seconds.", "5",
            GetValues: _ => ["5///5 seconds (Default)", "6///6 seconds", "8///8 seconds", "10///10 seconds", "12///12 seconds", "15///15 seconds"],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_h3_params"));

        ResolutionParam_H3 = T2IParamTypes.Register<string>(new("MiniMax HThree Video Resolution",
            "Output resolution. H3 uses its own scale rather than 480p/720p/1080p.", "2K",
            GetValues: _ => ["768P///768P (Fast)", "2K///2K (Default)", "4K///4K (Highest)"],
            OrderPriority: -8, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_h3_params"));

        AspectRatioParam_H3 = T2IParamTypes.Register<string>(new("MiniMax HThree Video Aspect Ratio",
            "Aspect ratio for H3 text-to-video. Image-to-video follows the input image instead.", "16:9",
            GetValues: _ => ["21:9///Ultra-wide (21:9)", "16:9///Widescreen (16:9)", "4:3///Standard (4:3)", "1:1///Square (1:1)", "3:4///Portrait (3:4)", "9:16///Portrait (9:16)"],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_h3_aspect"));

        AspectRatioParam_H3Ref = T2IParamTypes.Register<string>(new("MiniMax HThree Reference Aspect Ratio",
            "Aspect ratio for H3 reference-to-video. 'Adaptive' follows the references.", "adaptive",
            GetValues: _ => ["adaptive///Adaptive (Default)", "21:9///Ultra-wide (21:9)", "16:9///Widescreen (16:9)", "4:3///Standard (4:3)", "1:1///Square (1:1)", "3:4///Portrait (3:4)", "9:16///Portrait (9:16)"],
            OrderPriority: -9, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_h3_ref_aspect"));

        DurationParam_KlingTurbo = T2IParamTypes.Register<string>(new("Kling Turbo Video Duration",
            "Length of the generated video, 3 to 15 seconds.\n" +
            "Kling V3 Turbo takes no aspect ratio, resolution, audio or seed controls.", "5",
            GetValues: _ => ["3///3 seconds", "4///4 seconds", "5///5 seconds (Default)", "6///6 seconds", "7///7 seconds", "8///8 seconds", "9///9 seconds", "10///10 seconds", "11///11 seconds", "12///12 seconds", "13///13 seconds", "14///14 seconds", "15///15 seconds"],
            OrderPriority: -10, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_kling_turbo_params"));

        // ===== FAL UTILITY PARAMETERS =====
        UpscaleFactorParam_FalUtility = T2IParamTypes.Register<double>(new("Upscale Factor",
            "How many times larger to make the image.\n" +
            "Only applies to upscaler models; ignored by background removal and face restoration.",
            "2", Min: 1.0, Max: 4.0, Step: 0.5, ViewType: ParamViewType.SLIDER,
            OrderPriority: -10, Group: T2IParamTypes.GroupSampling, FeatureFlag: "fal_utility_params"));

        VideoUrlParam_FalUtility = T2IParamTypes.Register<string>(new("Input Video URL",
            "Publicly accessible URL of the video to process.\n" +
            "Required by the video utility models (video upscale, video background removal),\n" +
            "which take a video rather than the Init Image used by the image utilities.",
            "", OrderPriority: -9, Group: T2IParamTypes.GroupSampling, FeatureFlag: "fal_utility_video_params"));

        // ===== SHARED MULTI-REFERENCE PARAMETERS =====
        RefImageUrlsParam = T2IParamTypes.Register<string>(new("Reference Image URLs",
            "Comma-separated URLs of reference images for subject and style.\n" +
            "Refer to them in your prompt in order (Image 1, Image 2, ...).\n" +
            "Seedance and MiniMax H3 accept up to 9; Wan 2.7 has no fixed cap.",
            "", OrderPriority: -6, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_ref_images"));

        RefVideoUrlsParam = T2IParamTypes.Register<string>(new("Reference Video URLs",
            "Comma-separated URLs of reference videos for motion.\n" +
            "Refer to them in your prompt in order (Video 1, Video 2, ...). Up to 3, 2-15s each.",
            "", OrderPriority: -5, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_ref_videos"));

        RefAudioUrlsParam = T2IParamTypes.Register<string>(new("Reference Audio URLs",
            "Comma-separated URLs of reference audio clips.\n" +
            "Refer to them in your prompt in order (Audio 1, Audio 2, ...). Up to 3, 2-15s each.\n" +
            "Requires at least one reference image or video alongside it.",
            "", OrderPriority: -4, Group: T2IParamTypes.GroupText2Video, FeatureFlag: "fal_ref_audio"));



        RegisterFeatureFlags();
        Program.Backends.RegisterBackendType<DynamicAPIBackend>("dynamic_api_backend", "3rd Party Paid API Backends", "Generate images using various API services (OpenAI, Ideogram, Black Forest Labs, Grok, Google, Fal.ai)", true);
        // All key types must be added to the accepted list first
        string[] keyTypes = ["openai_api", "bfl_api", "ideogram_api", "grok_api", "google_api", "fal_api"];
        foreach (string keyType in keyTypes)
        {
            BasicAPIFeatures.AcceptedAPIKeyTypes.Add(keyType);
        }
        _ = APIProviderRegistry.Instance;
        WebAPI.APIBackendsAPI.Register();
        // A model declaring a family nothing knows about would silently lose all its params, so fail loudly at startup.
        List<string> unknown = ModelCapabilities.UnknownFamilies(APIProviderRegistry.Instance.ModelsByFullName.Values);
        if (unknown.Count > 0)
        {
            Logs.Error($"[APIBackends] Models declare unknown param families: {string.Join(", ", unknown)}. Their parameters will not appear.");
        }
        RegisterApiKeyIfNeeded("openai_api", "openai", "OpenAI (ChatGPT)", "https://platform.openai.com/api-keys", new HtmlString("To use OpenAI models in SwarmUI (via Hartsy extensions), you must set your OpenAI API key."));
        RegisterApiKeyIfNeeded("bfl_api", "black_forest", "Black Forest Labs (FLUX)", "https://dashboard.bfl.ai/", new HtmlString("To use Black Forest in SwarmUI (via Hartsy extensions), you must set your Black Forest API key."));
        RegisterApiKeyIfNeeded("ideogram_api", "ideogram", "Ideogram", "https://developer.ideogram.ai/ideogram-api/api-setup", new HtmlString("To use Ideogram in SwarmUI (via Hartsy extensions), you must set your Ideogram API key."));
        RegisterApiKeyIfNeeded("grok_api", "grok", "Grok", "https://accounts.x.ai/sign-up?redirect=grok-com", new HtmlString("To use Grok in SwarmUI (via Hartsy extensions), you must set your Grok API key."));
        RegisterApiKeyIfNeeded("google_api", "google", "Google (Gemini)", "https://ai.google.dev/gemini-api/docs/api-key", new HtmlString("To use Google models in SwarmUI (via Hartsy extensions), you must set your Google API key."));
        RegisterApiKeyIfNeeded("fal_api", "fal", "Fal.ai (600+ Models)", "https://fal.ai/dashboard/keys", new HtmlString("To use Fal.ai models in SwarmUI (via Hartsy extensions), you must set your Fal.ai API key."));
        Logs.Init("Hartsy's APIBackends extension V1.1 has successfully started.");
    }

    /// <summary>Safely registers an API key if it's not already registered</summary>
    private static void RegisterApiKeyIfNeeded(string keyType, string jsPrefix, string title, string createLink, HtmlString infoHtml)
    {
        try
        {
            if (!UserUpstreamApiKeys.KeysByType.ContainsKey(keyType))
            {
                UserUpstreamApiKeys.Register(new(keyType, jsPrefix, title, createLink, infoHtml));
                Logs.Verbose($"Registered API key type: {keyType}");
            }
            else
            {
                Logs.Verbose($"API key type '{keyType}' already registered, skipping registration");
            }
        }
        catch (Exception ex)
        {
            Logs.Warning($"Failed to register API key type '{keyType}': {ex.Message}");
        }
    }

    /// <summary>Registers all feature flags that should be disregarded for API backends.</summary>
    private static void RegisterFeatureFlags()
    {
        // Provider-level feature flags
        string[] providerFlags = ["openai_api", "ideogram_api", "bfl_api", "grok_api", "google_api", "fal_api"];

        // Model-specific feature flags
        string[] modelFlags = [
            "flux_2_flex_params", "gpt-image-1.5_params", "gpt_image_params", "openai_image_size",
            "ideogram_v1_params", "ideogram_v2_params", "ideogram_v3_params", "ideogram_v4_params", "ideogram_style",
            "flux_ultra_params", "flux_pro_params", "flux_dev_params",
            "flux_kontext_pro_params", "flux_kontext_max_params", "flux_2_max_params", "flux_2_pro_params",
            "flux_2_klein_params", "bfl_prompt_enhance",
            "grok_2_image_params", "google_gemini_params", "google_gemini3_params",
            "fal_t2i_params", "fal_i2i_params", "fal_video_params", "fal_utility_params",
            "fal_aspect_image", "fal_resolution_image", "fal_recraft_params",
            "fal_kling_video_params", "fal_veo_video_params",
            "fal_luma_video_params", "fal_minimax_video_params", "fal_hunyuan_video_params",
            "fal_seedance2_video_params", "fal_seedance1_video_params", "fal_seedance_ref_params",
            "fal_utility_video_params",
            "fal_video_audio", "fal_video_negative",
            "fal_wan22_params", "fal_pixverse_params", "fal_ltx2_params", "fal_ltx13b_params",
            "fal_vidu_params", "fal_pika_params", "fal_kandinsky_params", "fal_cogvideox_params",
            "fal_wan25_params", "fal_wan26_params", "fal_wan27_params", "fal_wan27ref_params",
            "fal_wan27_aspect", "fal_wan2x_resolution", "fal_wan_audio", "fal_prompt_expansion",
            "fal_wan_multishot", "fal_end_image_url", "fal_kling_turbo_params", "fal_seedance25_params", "fal_seedance2_duration",
            "fal_ref_images", "fal_ref_videos", "fal_ref_audio",
            "fal_h3_params", "fal_h3_aspect", "fal_h3_ref_aspect", "fal_flux3_params", "bfl_flux3_params",
            "fal_img_common", "fal_img_size", "fal_img_steps", "fal_flux2_params", "fal_nb2_params",
            "fal_flux2_edit_params"
        ];

        // Features incompatible with API backends (local-only features)
        string[] incompatibleFlags = [
            "sampling", "zero_negative", "refiners", "controlnet", "variation_seed",
            "video", "autowebui", "comfyui", "frameinterps", "ipadapter", "sdxl",
            "dynamic_thresholding", "cascade", "sd3", "flux-dev", "seamless",
            "freeu", "teacache", "text2video", "yolov8", "aitemplate", "sdcpp"
        ];

        // Register all flags
        foreach (string flag in providerFlags) T2IEngine.DisregardedFeatureFlags.Add(flag);
        foreach (string flag in modelFlags) T2IEngine.DisregardedFeatureFlags.Add(flag);
        foreach (string flag in incompatibleFlags) T2IEngine.DisregardedFeatureFlags.Add(flag);
    }
}