@civitai/client 0.2.0-beta.2 → 0.2.0-beta.21

package/dist/generated/types.gen.d.ts

@@ -1,3 +1,84 @@
+/**
+ * Base input for AI Toolkit training across all ecosystems
+ */
+export type AiToolkitTrainingInput = TrainingInput & {
+  engine: 'ai-toolkit';
+} & {
+  ecosystem: string;
+  /**
+   * Number of training epochs. An epoch is one complete pass through the training dataset.
+   * Maximum of 20 epochs can be specified.
+   * Note: ai-toolkit uses steps internally, calculated based on epochs, image count, and internal parameters.
+   */
+  epochs?: number;
+  /**
+   * Specify the maximum resolution of training images. If the training images exceed the resolution specified here, they will be scaled down to this resolution
+   */
+  resolution?: number | null;
+  /**
+   * Sets the learning rate for the model. This is the learning rate when performing additional learning on each attention block (and other blocks depending on the setting).
+   */
+  lr?: number;
+  /**
+   * Sets the learning rate for the text encoder. Only used when TrainTextEncoder is true. For models with multiple text encoders, this applies to all of them.
+   */
+  textEncoderLr?: number | null;
+  /**
+   * Whether to train the text encoder(s) alongside the model. Enabling this can improve prompt understanding but increases training time and memory usage.
+   */
+  trainTextEncoder?: boolean | null;
+  /**
+   * You can change the learning rate in the middle of learning. A scheduler is a setting for how to change the learning rate.
+   */
+  lrScheduler?: 'constant' | 'constant_with_warmup' | 'cosine' | 'linear' | 'step';
+  /**
+   * The optimizer determines how to update the neural net weights during training.
+   * Various methods have been proposed for smart learning, but the most commonly used in LoRA learning is "adamw8bit".
+   */
+  optimizerType?:
+    | 'adam'
+    | 'adamw'
+    | 'adamw8bit'
+    | 'adam8bit'
+    | 'lion'
+    | 'lion8bit'
+    | 'adafactor'
+    | 'adagrad'
+    | 'prodigy'
+    | 'prodigy8bit';
+  /**
+   * The larger the Dim setting, the more learning information can be stored, but the possibility of learning unnecessary information other than the learning target increases. A larger Dim also increases LoRA file size.
+   */
+  networkDim?: number | null;
+  /**
+   * The smaller the Network alpha value, the larger the stored LoRA neural net weights.
+   * For example, with an Alpha of 16 and a Dim of 32, the strength of the weight used is 16/32 = 0.5,
+   * meaning that the learning rate is only half as powerful as the Learning Rate setting.
+   *
+   * If Alpha and Dim are the same number, the strength used will be 1 and will have no effect on the learning rate.
+   */
+  networkAlpha?: number | null;
+  /**
+   * Adds noise to training images. 0 adds no noise at all. A value of 1 adds strong noise.
+   */
+  noiseOffset?: number | null;
+  /**
+   * If this option is turned on, the image will be horizontally flipped randomly. It can learn left and right angles, which is useful when you want to learn symmetrical people and objects.
+   */
+  flipAugmentation?: boolean;
+  /**
+   * Randomly changes the order of your tags during training. The intent of shuffling is to improve learning. If you are using captions (sentences), this option has no meaning.
+   */
+  shuffleTokens?: boolean;
+  /**
+   * If your training images have tags, you can randomly shuffle them.
+   * However, if you have words that you want to keep at the beginning, you can use this option to specify "Keep the first 0 words at the beginning".
+   * This option does nothing if the Shuffle Tokens option is off.
+   */
+  keepTokens?: number;
+} & {
+  engine: 'ai-toolkit';
+};
 export type AgeClassificationInput = {
   /**
    * An optional model to use for age classification. If not provided, the default model will determined by the worker
@@ -13,14 +94,7 @@ export type AgeClassificationOutput = {
     [key: string]: Array<AgeClassifierLabel>;
   };
   hasMinor: boolean;
-  prediction: AgeClassificationPrediction;
 };
-export declare const AgeClassificationPrediction: {
-  readonly PASS: 'pass';
-  readonly FAIL: 'fail';
-};
-export type AgeClassificationPrediction =
-  (typeof AgeClassificationPrediction)[keyof typeof AgeClassificationPrediction];
 /**
  * Age classification
  */
@@ -47,6 +121,27 @@ export type AgeClassifierLabel = {
   isMinor: boolean;
   boundingBox: Array<number>;
 };
+export declare const AnimalPoseBboxDetector: {
+  readonly YOLOX_L_TORCHSCRIPT_PT: 'yolox_l.torchscript.pt';
+  readonly YOLOX_L_ONNX: 'yolox_l.onnx';
+  readonly YOLO_NAS_L_FP16_ONNX: 'yolo_nas_l_fp16.onnx';
+  readonly YOLO_NAS_M_FP16_ONNX: 'yolo_nas_m_fp16.onnx';
+  readonly YOLO_NAS_S_FP16_ONNX: 'yolo_nas_s_fp16.onnx';
+};
+export type AnimalPoseBboxDetector =
+  (typeof AnimalPoseBboxDetector)[keyof typeof AnimalPoseBboxDetector];
+export declare const AnimalPoseEstimator: {
+  readonly RTMPOSE_M_AP10K_256_BS5_TORCHSCRIPT_PT: 'rtmpose-m_ap10k_256_bs5.torchscript.pt';
+  readonly RTMPOSE_M_AP10K_256_ONNX: 'rtmpose-m_ap10k_256.onnx';
+};
+export type AnimalPoseEstimator = (typeof AnimalPoseEstimator)[keyof typeof AnimalPoseEstimator];
+export declare const AnylineMergeWith: {
+  readonly LINEART_STANDARD: 'lineart_standard';
+  readonly LINEART_REALISTIC: 'lineart_realistic';
+  readonly LINEART_ANIME: 'lineart_anime';
+  readonly MANGA_LINE: 'manga_line';
+};
+export type AnylineMergeWith = (typeof AnylineMergeWith)[keyof typeof AnylineMergeWith];
 export type BatchOcrSafetyClassificationInput = {
   mediaUrls: Array<string>;
 };
@@ -96,6 +191,17 @@ export declare const BuzzClientAccount: {
   readonly FAKE_RED: 'fakeRed';
 };
 export type BuzzClientAccount = (typeof BuzzClientAccount)[keyof typeof BuzzClientAccount];
+/**
+ * AI Toolkit training for Chroma models
+ */
+export type ChromaAiToolkitTrainingInput = AiToolkitTrainingInput & {} & {
+  ecosystem: 'chroma';
+};
+export declare const CoarseMode: {
+  readonly DISABLE: 'disable';
+  readonly ENABLE: 'enable';
+};
+export type CoarseMode = (typeof CoarseMode)[keyof typeof CoarseMode];
 export type ComfyInput = {
   /**
    * Get the comfy workflow that needs to be executed
@@ -158,10 +264,91 @@ export declare const ContainerFormat: {
   readonly WEB_M: 'webM';
 };
 export type ContainerFormat = (typeof ContainerFormat)[keyof typeof ContainerFormat];
+/**
+ * Input configuration for the ConvertImage workflow step.
+ */
+export type ConvertImageInput = {
+  /**
+   * The source image to convert.
+   */
+  image: string;
+  /**
+   * Optional list of transforms to apply to the image before conversion.
+   * Transforms are applied in order.
+   */
+  transforms?: Array<ImageTransform>;
+  output: ImageOutputFormat;
+};
+/**
+ * Output from the ConvertImage workflow step.
+ */
+export type ConvertImageOutput = {
+  blob: ImageBlob;
+};
+/**
+ * A workflow step that converts images to different formats and applies optional transforms.
+ */
+export type ConvertImageStep = WorkflowStep & {
+  $type: 'convertImage';
+} & {
+  input: ConvertImageInput;
+  output?: ConvertImageOutput;
+} & {
+  $type: 'convertImage';
+};
+/**
+ * A workflow step that converts images to different formats and applies optional transforms.
+ */
+export type ConvertImageStepTemplate = WorkflowStepTemplate & {
+  $type: 'convertImage';
+} & {
+  input: ConvertImageInput;
+} & {
+  $type: 'convertImage';
+};
 export type CursedArrayOfTelemetryCursorAndWorkflow = {
   next: string;
   items: Array<Workflow>;
 };
+export declare const DensePoseColormap: {
+  readonly 'VIRIDIS (_MAGIC_ANIMATE)': 'Viridis (MagicAnimate)';
+  readonly 'PARULA (_CIVIT_AI)': 'Parula (CivitAI)';
+};
+export type DensePoseColormap = (typeof DensePoseColormap)[keyof typeof DensePoseColormap];
+export declare const DensePoseModel: {
+  readonly DENSEPOSE_R50_FPN_DL_TORCHSCRIPT: 'densepose_r50_fpn_dl.torchscript';
+  readonly DENSEPOSE_R101_FPN_DL_TORCHSCRIPT: 'densepose_r101_fpn_dl.torchscript';
+};
+export type DensePoseModel = (typeof DensePoseModel)[keyof typeof DensePoseModel];
+export declare const DepthAnythingCheckpoint: {
+  readonly DEPTH_ANYTHING_VITL14_PTH: 'depth_anything_vitl14.pth';
+  readonly DEPTH_ANYTHING_VITB14_PTH: 'depth_anything_vitb14.pth';
+  readonly DEPTH_ANYTHING_VITS14_PTH: 'depth_anything_vits14.pth';
+};
+export type DepthAnythingCheckpoint =
+  (typeof DepthAnythingCheckpoint)[keyof typeof DepthAnythingCheckpoint];
+export declare const DepthAnythingV2Checkpoint: {
+  readonly DEPTH_ANYTHING_V2_VITG_PTH: 'depth_anything_v2_vitg.pth';
+  readonly DEPTH_ANYTHING_V2_VITL_PTH: 'depth_anything_v2_vitl.pth';
+  readonly DEPTH_ANYTHING_V2_VITB_PTH: 'depth_anything_v2_vitb.pth';
+  readonly DEPTH_ANYTHING_V2_VITS_PTH: 'depth_anything_v2_vits.pth';
+};
+export type DepthAnythingV2Checkpoint =
+  (typeof DepthAnythingV2Checkpoint)[keyof typeof DepthAnythingV2Checkpoint];
+export declare const DwPoseBboxDetector: {
+  readonly YOLOX_L_ONNX: 'yolox_l.onnx';
+  readonly YOLOX_L_TORCHSCRIPT_PT: 'yolox_l.torchscript.pt';
+  readonly YOLO_NAS_L_FP16_ONNX: 'yolo_nas_l_fp16.onnx';
+  readonly YOLO_NAS_M_FP16_ONNX: 'yolo_nas_m_fp16.onnx';
+  readonly YOLO_NAS_S_FP16_ONNX: 'yolo_nas_s_fp16.onnx';
+};
+export type DwPoseBboxDetector = (typeof DwPoseBboxDetector)[keyof typeof DwPoseBboxDetector];
+export declare const DwPoseEstimator: {
+  readonly DW_LL_UCOCO_384_BS5_TORCHSCRIPT_PT: 'dw-ll_ucoco_384_bs5.torchscript.pt';
+  readonly DW_LL_UCOCO_384_ONNX: 'dw-ll_ucoco_384.onnx';
+  readonly DW_LL_UCOCO_ONNX: 'dw-ll_ucoco.onnx';
+};
+export type DwPoseEstimator = (typeof DwPoseEstimator)[keyof typeof DwPoseEstimator];
 /**
  * Represents the input information needed for the Echo workflow step.
  */
@@ -230,8 +417,23 @@ export declare const FileFormat: {
   readonly DIFFUSERS: 'diffusers';
   readonly CORE_ML: 'coreML';
   readonly ONNX: 'onnx';
+  readonly TAR: 'tar';
 };
 export type FileFormat = (typeof FileFormat)[keyof typeof FileFormat];
+/**
+ * AI Toolkit training for Flux.1 models
+ */
+export type Flux1AiToolkitTrainingInput = AiToolkitTrainingInput & {
+  modelVariant: string;
+} & {
+  ecosystem: 'flux1';
+};
+/**
+ * AI Toolkit training for Flux.1 Dev models
+ */
+export type Flux1DevAiToolkitTrainingInput = Flux1AiToolkitTrainingInput & {} & {
+  modelVariant: 'dev';
+};
 export type Flux1KontextDevImageGenInput = Flux1KontextImageGenInput & {
   readonly model: string;
 } & {
@@ -261,11 +463,195 @@ export type Flux1KontextProImageGenInput = Flux1KontextImageGenInput & {
 } & {
   model: 'pro';
 };
+/**
+ * AI Toolkit training for Flux.1 Schnell models
+ */
+export type Flux1SchnellAiToolkitTrainingInput = Flux1AiToolkitTrainingInput & {} & {
+  modelVariant: 'schnell';
+};
+export type Flux2DevCreateImageInput = Flux2DevImageGenInput & {
+  readonly operation: string;
+} & {
+  operation: 'createImage';
+};
+export type Flux2DevEditImageInput = Flux2DevImageGenInput & {
+  images?: Array<string>;
+  readonly operation: string;
+} & {
+  operation: 'editImage';
+};
+/**
+ * Input for Flux 2 Dev image editing LoRA training via FAL.
+ */
+export type Flux2DevEditImageResourceTrainingInput = ImageResourceTrainingInput & {
+  engine: 'flux2-dev-edit';
+} & {
+  /**
+   * Number of training steps. Must be in increments of 100.
+   */
+  steps?: number;
+  /**
+   * Learning rate for training.
+   */
+  learningRate?: number;
+  /**
+   * Default caption to use if caption files are missing from training data.
+   */
+  defaultCaption?: string | null;
+  /**
+   * Number of reference images per training pair (1-4).
+   * Affects cost calculation via reference multiplier.
+   */
+  referenceImageCount?: number;
+} & {
+  engine: 'flux2-dev-edit';
+};
+export type Flux2DevImageGenInput = Flux2ImageGenInput & {
+  operation: string;
+  guidanceScale?: number;
+  numInferenceSteps?: number;
+  loras?: Array<ImageGenInputLora>;
+  readonly modelVariant?: string;
+} & {
+  model: 'dev';
+};
+/**
+ * Input for Flux 2 Dev text-to-image LoRA training via FAL.
+ */
+export type Flux2DevImageResourceTrainingInput = ImageResourceTrainingInput & {
+  engine: 'flux2-dev';
+} & {
+  /**
+   * Number of training steps. Must be in increments of 100.
+   */
+  steps?: number;
+  /**
+   * Learning rate for training.
+   */
+  learningRate?: number;
+  /**
+   * Default caption to use if caption files are missing from training data.
+   */
+  defaultCaption?: string | null;
+} & {
+  engine: 'flux2-dev';
+};
+export type Flux2FlexCreateImageInput = Flux2FlexImageGenInput & {
+  readonly operation: string;
+} & {
+  operation: 'createImage';
+};
+export type Flux2FlexEditImageInput = Flux2FlexImageGenInput & {
+  images?: Array<string>;
+  readonly operation: string;
+} & {
+  operation: 'editImage';
+};
+export type Flux2FlexImageGenInput = Flux2ImageGenInput & {
+  operation: string;
+  guidanceScale?: number;
+  numInferenceSteps?: number;
+  readonly modelVariant?: string;
+} & {
+  model: 'flex';
+};
+export type Flux2ImageGenInput = ImageGenInput & {
+  engine: 'flux2';
+} & {
+  model: string;
+  prompt: string;
+  width?: number;
+  height?: number;
+  outputFormat?: 'jpeg' | 'png';
+  seed?: number | null;
+  quantity?: number;
+  enablePromptExpansion?: boolean;
+  /**
+   * The model variant (dev, flex, pro)
+   */
+  readonly modelVariant?: string;
+  /**
+   * The operation type (createImage, editImage)
+   */
+  readonly operation?: string;
+} & {
+  engine: 'flux2';
+};
+export type Flux2MaxCreateImageInput = Flux2MaxImageGenInput & {
+  readonly operation: string;
+} & {
+  operation: 'createImage';
+};
+export type Flux2MaxEditImageInput = Flux2MaxImageGenInput & {
+  images?: Array<string>;
+  readonly operation: string;
+} & {
+  operation: 'editImage';
+};
+export type Flux2MaxImageGenInput = Flux2ImageGenInput & {
+  operation: string;
+  readonly modelVariant?: string;
+} & {
+  model: 'max';
+};
+export type Flux2ProCreateImageInput = Flux2ProImageGenInput & {
+  readonly operation: string;
+} & {
+  operation: 'createImage';
+};
+export type Flux2ProEditImageInput = Flux2ProImageGenInput & {
+  images?: Array<string>;
+  readonly operation: string;
+} & {
+  operation: 'editImage';
+};
+export type Flux2ProImageGenInput = Flux2ImageGenInput & {
+  operation: string;
+  readonly modelVariant?: string;
+} & {
+  model: 'pro';
+};
 export type FluxDevFastImageResourceTrainingInput = ImageResourceTrainingInput & {
   engine: 'flux-dev-fast';
 } & {} & {
   engine: 'flux-dev-fast';
 };
+export type Gemini25FlashCreateImageGenInput = Gemini25FlashImageGenInput & {} & {
+  operation: 'createImage';
+};
+export type Gemini25FlashEditImageGenInput = Gemini25FlashImageGenInput & {
+  images: Array<string>;
+} & {
+  operation: 'editImage';
+};
+export type Gemini25FlashImageGenInput = GeminiImageGenInput & {
+  operation: string;
+  quantity?: number;
+} & {
+  model: '2.5-flash';
+};
+export type GeminiImageGenInput = ImageGenInput & {
+  engine: 'gemini';
+} & {
+  model: string;
+  prompt: string;
+} & {
+  engine: 'gemini';
+};
+/**
+ * GIF output format configuration.
+ */
+export type GifOutputFormat = ImageOutputFormat & {
+  format: 'gif';
+} & {
+  /**
+   * Maximum number of frames to include in the output. Set to 1 to extract only the first frame from animated images.
+   * When null, all frames are preserved.
+   */
+  maxFrames?: number | null;
+} & {
+  format: 'gif';
+};
 export type GoogleImageGenInput = ImageGenInput & {
   engine: 'google';
 } & {
@@ -356,6 +742,14 @@ export type ImageBlob = Blob & {
 } & {
   width?: number | null;
   height?: number | null;
+  /**
+   * Gets a url that can be used to preview a resized version of the image.
+   */
+  previewUrl?: string | null;
+  /**
+   * Gets when the preview url is set to expire.
+   */
+  previewUrlExpiresAt?: string | null;
 } & {
   type: 'image';
 };
@@ -371,6 +765,10 @@ export type ImageGenOutput = {
    * A collection of output images.
    */
   images: Array<ImageBlob>;
+  /**
+   * An optional list of errors related to generation failures
+   */
+  errors?: Array<string> | null;
 };
 /**
  * Image Generation
@@ -425,6 +823,12 @@ export type ImageJobNetworkParams = {
    */
   type?: string | null;
 };
+/**
+ * Base class for image output formats. Uses "format" as the type discriminator.
+ */
+export type ImageOutputFormat = {
+  format: string;
+};
 export declare const ImageResouceTrainingModerationStatus: {
   readonly EVALUATING: 'evaluating';
   readonly UNDER_REVIEW: 'underReview';
@@ -458,6 +862,10 @@ export type ImageResourceTrainingInput = {
    * A selection of sample prompts.
    */
   samplePrompts?: Array<string>;
+  /**
+   * An optional negative prompt that will get applied when generating samples
+   */
+  negativePrompt?: string | null;
 };
 export type ImageResourceTrainingOutput = {
   moderationStatus: ImageResouceTrainingModerationStatus;
@@ -504,6 +912,12 @@ export type ImageResourceTrainingStepTemplate = WorkflowStepTemplate & {
 } & {
   $type: 'imageResourceTraining';
 };
+/**
+ * Base class for image transforms that can be applied during image conversion.
+ */
+export type ImageTransform = {
+  type: string;
+};
 /**
  * Available image transformers.
  */
@@ -547,6 +961,31 @@ export type ImageUploadStepTemplate = WorkflowStepTemplate & {
 } & {
   $type: 'imageUpload';
 };
+export type ImageUpscalerInput = {
+  /**
+   * Either A URL, A DataURL or a Base64 string
+   */
+  image: string;
+  scaleFactor?: number;
+};
+export type ImageUpscalerOutput = {
+  blob: ImageBlob;
+};
+export type ImageUpscalerStep = WorkflowStep & {
+  $type: 'imageUpscaler';
+} & {
+  input: ImageUpscalerInput;
+  output?: ImageUpscalerOutput;
+} & {
+  $type: 'imageUpscaler';
+};
+export type ImageUpscalerStepTemplate = WorkflowStepTemplate & {
+  $type: 'imageUpscaler';
+} & {
+  input: ImageUpscalerInput;
+} & {
+  $type: 'imageUpscaler';
+};
 export type Imagen4ImageGenInput = GoogleImageGenInput & {
   prompt: string;
   negativePrompt?: string;
@@ -568,6 +1007,19 @@ export declare const JobSupport: {
  * Available levels of job support.
  */
 export type JobSupport = (typeof JobSupport)[keyof typeof JobSupport];
+/**
+ * JPEG output format configuration.
+ */
+export type JpegOutputFormat = ImageOutputFormat & {
+  format: 'jpeg';
+} & {
+  /**
+   * Quality setting for JPEG compression (1-100). Higher values produce better quality but larger files.
+   */
+  quality?: number;
+} & {
+  format: 'jpeg';
+};
 /**
  * Array of operations to perform
  */
@@ -637,9 +1089,10 @@ export declare const KlingMode: {
 export type KlingMode = (typeof KlingMode)[keyof typeof KlingMode];
 export declare const KlingModel: {
   readonly V1: 'v1';
-  readonly V1_5: 'v1_5';
-  readonly V1_6: 'v1_6';
+  readonly V1_5: 'v1.5';
+  readonly V1_6: 'v1.6';
   readonly V2: 'v2';
+  readonly V2_5_TURBO: 'v2.5-turbo';
 };
 export type KlingModel = (typeof KlingModel)[keyof typeof KlingModel];
 export declare const KlingVideoGenAspectRatio: {
@@ -765,6 +1218,11 @@ export type KohyaImageResourceTrainingInput = ImageResourceTrainingInput & {
 } & {
   engine: 'kohya';
 };
+export declare const LeresBoost: {
+  readonly DISABLE: 'disable';
+  readonly ENABLE: 'enable';
+};
+export type LeresBoost = (typeof LeresBoost)[keyof typeof LeresBoost];
 export declare const LightricksAspectRatio: {
   readonly '1:1': '1:1';
   readonly '16:9': '16:9';
@@ -792,22 +1250,129 @@ export type LightricksVideoGenInput = VideoGenInput & {
 } & {
   engine: 'lightricks';
 };
-export type MiniMaxVideoGenInput = VideoGenInput & {
-  engine: 'minimax';
-} & {
-  model?: MiniMaxVideoGenModel;
-  enablePromptEnhancer?: boolean;
+/**
+ * Represents the input information needed for the MediaHash workflow step.
+ */
+export type MediaHashInput = {
+  mediaUrl: string;
   /**
-   * Either A URL, A DataURL or a Base64 string
+   * The types of hashes to generate.
    */
-  sourceImage?: string | null;
-} & {
-  engine: 'minimax';
+  hashTypes: Array<MediaHashType>;
 };
-export declare const MiniMaxVideoGenModel: {
-  readonly HAILOU: 'hailou';
+/**
+ * Represents the output information returned from the MediaHash workflow step.
+ */
+export type MediaHashOutput = {
+  /**
+   * The generated hashes, keyed by hash type (e.g., "perceptual" -> "12345678").
+   */
+  hashes: {
+    [key: string]: string;
+  };
 };
-export type MiniMaxVideoGenModel = (typeof MiniMaxVideoGenModel)[keyof typeof MiniMaxVideoGenModel];
+/**
+ * MediaHash
+ */
+export type MediaHashStep = WorkflowStep & {
+  $type: 'mediaHash';
+} & {
+  input: MediaHashInput;
+  output?: MediaHashOutput;
+} & {
+  $type: 'mediaHash';
+};
+/**
+ * MediaHash
+ */
+export type MediaHashStepTemplate = WorkflowStepTemplate & {
+  $type: 'mediaHash';
+} & {
+  input: MediaHashInput;
+} & {
+  $type: 'mediaHash';
+};
+/**
+ * Represents the type of hash algorithm to use for media content.
+ */
+export declare const MediaHashType: {
+  readonly PERCEPTUAL: 'perceptual';
+};
+/**
+ * Represents the type of hash algorithm to use for media content.
+ */
+export type MediaHashType = (typeof MediaHashType)[keyof typeof MediaHashType];
+/**
+ * Represents the input information needed for the MediaRating workflow step.
+ */
+export type MediaRatingInput = {
+  mediaUrl: string;
+  /**
+   * The engine to use for media rating. Valid values: "default" (HiveVLM) or "civitai".
+   */
+  engine?: string;
+};
+/**
+ * Represents the output information returned from the MediaRating workflow step.
+ */
+export type MediaRatingOutput = {
+  nsfwLevel: NsfwLevel;
+  /**
+   * The reason the content was blocked, if any.
+   */
+  blockedReason?: string | null;
+  /**
+   * Whether the content is blocked.
+   */
+  isBlocked: boolean;
+  /**
+   * Detected content labels (e.g., "Animal", "Child", etc.).
+   */
+  labels?: Array<string> | null;
+};
+/**
+ * MediaRating
+ */
+export type MediaRatingStep = WorkflowStep & {
+  $type: 'mediaRating';
+} & {
+  input: MediaRatingInput;
+  output?: MediaRatingOutput;
+} & {
+  $type: 'mediaRating';
+};
+/**
+ * MediaRating
+ */
+export type MediaRatingStepTemplate = WorkflowStepTemplate & {
+  $type: 'mediaRating';
+} & {
+  input: MediaRatingInput;
+} & {
+  $type: 'mediaRating';
+};
+export declare const Metric3dBackbone: {
+  readonly VIT_SMALL: 'vit-small';
+  readonly VIT_LARGE: 'vit-large';
+  readonly VIT_GIANT2: 'vit-giant2';
+};
+export type Metric3dBackbone = (typeof Metric3dBackbone)[keyof typeof Metric3dBackbone];
+export type MiniMaxVideoGenInput = VideoGenInput & {
+  engine: 'minimax';
+} & {
+  model?: MiniMaxVideoGenModel;
+  enablePromptEnhancer?: boolean;
+  /**
+   * Either A URL, A DataURL or a Base64 string
+   */
+  sourceImage?: string | null;
+} & {
+  engine: 'minimax';
+};
+export declare const MiniMaxVideoGenModel: {
+  readonly HAILOU: 'hailou';
+};
+export type MiniMaxVideoGenModel = (typeof MiniMaxVideoGenModel)[keyof typeof MiniMaxVideoGenModel];
 export type MochiVideoGenInput = VideoGenInput & {
   engine: 'mochi';
 } & {
@@ -820,17 +1385,10 @@ export type MusubiImageResourceTrainingInput = ImageResourceTrainingInput & {
   engine: 'musubi';
 } & {
   /**
-   * An epoch is one set of learning. By default, we will save a maximum of 20 epochs (evenly distributed), and they are all available for download.
-   */
-  maxTrainEpochs?: number;
-  /**
-   * Num Repeats defines how many times each individual image gets put into VRAM. As opposed to batch size, which is how many images are placed into VRAM at once.
+   * Number of training epochs. An epoch is one complete pass through the training dataset.
+   * Maximum of 20 epochs can be specified.
    */
-  numRepeats?: number;
-  /**
-   * Batch size is the number of images that will be placed into VRAM at once. A batch size of 2 will train two images at a time, simultaneously.
-   */
-  trainBatchSize?: number | null;
+  epochs?: number;
   /**
    * Specify the maximum resolution of training images. If the training images exceed the resolution specified here, they will be scaled down to this resolution
    */
@@ -875,13 +1433,23 @@ export type MusubiImageResourceTrainingInput = ImageResourceTrainingInput & {
 };
 export declare const NsfwLevel: {
   readonly PG: 'pg';
-  readonly P_G13: 'pG13';
+  readonly PG13: 'pg13';
   readonly R: 'r';
   readonly X: 'x';
   readonly XXX: 'xxx';
   readonly NA: 'na';
 };
 export type NsfwLevel = (typeof NsfwLevel)[keyof typeof NsfwLevel];
+export type NanoBananaProImageGenInput = GoogleImageGenInput & {
+  prompt: string;
+  aspectRatio?: '21:9' | '16:9' | '3:2' | '4:3' | '5:4' | '1:1' | '4:5' | '3:4' | '2:3' | '9:16';
+  numImages?: number;
+  resolution?: '1K' | '2K' | '4K';
+  outputFormat?: 'jpeg' | 'png' | 'webp';
+  images?: Array<string>;
+} & {
+  model: 'nano-banana-pro';
+};
 export type OpenAiDallE2CreateImageGenInput = OpenAiDallE2ImageGenInput & {
   background?: 'auto' | 'transparent' | 'opaque';
 } & {
@@ -921,6 +1489,33 @@ export type OpenAiDallE3ImageGenInput = OpenApiImageGenInput & {
 } & {
   model: 'dall-e-3';
 };
+export type OpenAiGpt15CreateImageInput = OpenAiGpt15ImageGenInput & {} & {
+  operation: 'createImage';
+};
+export type OpenAiGpt15EditImageInput = OpenAiGpt15ImageGenInput & {
+  images: Array<string>;
+  /**
+   * Input fidelity: low or high
+   */
+  inputFidelity?: 'low' | 'high';
+  /**
+   * Image size for edit mode: auto, 1024x1024, 1536x1024, or 1024x1536
+   */
+  size?: 'auto' | '1024x1024' | '1536x1024' | '1024x1536';
+} & {
+  operation: 'editImage';
+};
+export type OpenAiGpt15ImageGenInput = OpenApiImageGenInput & {
+  operation: string;
+  prompt: string;
+  size?: '1024x1024' | '1536x1024' | '1024x1536';
+  quantity?: number;
+  background?: 'auto' | 'transparent' | 'opaque';
+  quality?: 'low' | 'medium' | 'high';
+  outputFormat?: 'jpeg' | 'png' | 'webp';
+} & {
+  model: 'gpt-image-1.5';
+};
 export type OpenAiGpt1CreateImageInput = OpenAiGpt1ImageGenInput & {} & {
   operation: 'createImage';
 };
@@ -951,6 +1546,317 @@ export type OpenApiImageGenInput = ImageGenInput & {
 } & {
   engine: 'openai';
 };
+export declare const OutputFormat: {
+  readonly PNG: 'png';
+  readonly JPEG: 'jpeg';
+  readonly WEB_P: 'webP';
+};
+export type OutputFormat = (typeof OutputFormat)[keyof typeof OutputFormat];
+/**
+ * PNG output format configuration.
+ */
+export type PngOutputFormat = ImageOutputFormat & {
+  format: 'png';
+} & {} & {
+  format: 'png';
+};
+export type PreprocessImageAnimalPoseInput = PreprocessImageInput & {
+  kind: 'animal-pose';
+} & {
+  bboxDetector?: AnimalPoseBboxDetector;
+  poseEstimator?: AnimalPoseEstimator;
+} & {
+  kind: 'animal-pose';
+};
+export type PreprocessImageAnimeLineartInput = PreprocessImageInput & {
+  kind: 'lineart-anime';
+} & {} & {
+  kind: 'lineart-anime';
+};
+export type PreprocessImageAnylineInput = PreprocessImageInput & {
+  kind: 'anyline';
+} & {
+  mergeWithLineart?: AnylineMergeWith;
+  lineartLowerBound?: number;
+  lineartUpperBound?: number;
+  objectMinSize?: number;
+  objectConnectivity?: number;
+} & {
+  kind: 'anyline';
+};
+export type PreprocessImageBaeNormalInput = PreprocessImageInput & {
+  kind: 'bae-normal';
+} & {} & {
+  kind: 'bae-normal';
+};
+export type PreprocessImageBinaryInput = PreprocessImageInput & {
+  kind: 'binary';
+} & {
+  binThreshold?: number;
+} & {
+  kind: 'binary';
+};
+export type PreprocessImageCannyInput = PreprocessImageInput & {
+  kind: 'canny';
+} & {
+  lowThreshold?: number;
+  highThreshold?: number;
+} & {
+  kind: 'canny';
+};
+export type PreprocessImageColorInput = PreprocessImageInput & {
+  kind: 'color';
+} & {} & {
+  kind: 'color';
+};
+export type PreprocessImageDensePoseInput = PreprocessImageInput & {
+  kind: 'densepose';
+} & {
+  model?: DensePoseModel;
+  colormap?: DensePoseColormap;
+} & {
+  kind: 'densepose';
+};
+export type PreprocessImageDepthAnythingInput = PreprocessImageInput & {
+  kind: 'depth-anything';
+} & {
+  checkpoint?: DepthAnythingCheckpoint;
+} & {
+  kind: 'depth-anything';
+};
+export type PreprocessImageDepthAnythingV2Input = PreprocessImageInput & {
+  kind: 'depth-anything-v2';
+} & {
+  checkpoint?: DepthAnythingV2Checkpoint;
+} & {
+  kind: 'depth-anything-v2';
+};
+export type PreprocessImageDsineNormalInput = PreprocessImageInput & {
+  kind: 'dsine-normal';
+} & {
+  fov?: number;
+  iterations?: number;
+} & {
+  kind: 'dsine-normal';
+};
+export type PreprocessImageDwPoseInput = PreprocessImageInput & {
+  kind: 'dwpose';
+} & {
+  detectHand?: boolean;
+  detectBody?: boolean;
+  detectFace?: boolean;
+  bboxDetector?: DwPoseBboxDetector;
+  poseEstimator?: DwPoseEstimator;
+} & {
+  kind: 'dwpose';
+};
+export type PreprocessImageFakeScribbleInput = PreprocessImageInput & {
+  kind: 'fake-scribble';
+} & {
+  safe?: SafeMode;
+} & {
+  kind: 'fake-scribble';
+};
+export type PreprocessImageHedInput = PreprocessImageInput & {
+  kind: 'hed';
+} & {
+  safe?: SafeMode;
+} & {
+  kind: 'hed';
+};
+export type PreprocessImageInput = {
+  kind: string;
+  /**
+   * Either A URL, A DataURL or a Base64 string
+   */
+  image: string;
+  resolution?: number;
+  /**
+   * Gets the preprocessor type identifier used to map to ComfyUI nodes.
+   * This is derived from the JsonDerivedType discriminator.
+   */
+  preprocessorType?: string;
+};
+export type PreprocessImageLeresDepthInput = PreprocessImageInput & {
+  kind: 'leres-depth';
+} & {
+  removeNearest?: number;
+  removeBackground?: number;
+  boost?: LeresBoost;
+} & {
+  kind: 'leres-depth';
+};
+export type PreprocessImageMangaLineartInput = PreprocessImageInput & {
+  kind: 'lineart-manga';
+} & {} & {
+  kind: 'lineart-manga';
+};
+export type PreprocessImageMediaPipeFaceInput = PreprocessImageInput & {
+  kind: 'mediapipe-face';
+} & {
+  maxFaces?: number;
+  minConfidence?: number;
+} & {
+  kind: 'mediapipe-face';
+};
+export type PreprocessImageMetric3dDepthInput = PreprocessImageInput & {
+  kind: 'metric3d-depth';
+} & {
+  backbone?: Metric3dBackbone;
+  fx?: number;
+  fy?: number;
+} & {
+  kind: 'metric3d-depth';
+};
+export type PreprocessImageMetric3dNormalInput = PreprocessImageInput & {
+  kind: 'metric3d-normal';
+} & {
+  backbone?: Metric3dBackbone;
+  fx?: number;
+  fy?: number;
+} & {
+  kind: 'metric3d-normal';
+};
+export type PreprocessImageMidasDepthInput = PreprocessImageInput & {
+  kind: 'midas-depth';
+} & {
+  a?: number;
+  backgroundThreshold?: number;
+} & {
+  kind: 'midas-depth';
+};
+export type PreprocessImageMidasNormalInput = PreprocessImageInput & {
+  kind: 'midas-normal';
+} & {
+  a?: number;
+  backgroundThreshold?: number;
+} & {
+  kind: 'midas-normal';
+};
+export type PreprocessImageMlsdInput = PreprocessImageInput & {
+  kind: 'mlsd';
+} & {
+  scoreThreshold?: number;
+  distanceThreshold?: number;
+} & {
+  kind: 'mlsd';
+};
+export type PreprocessImageOneFormerAde20kInput = PreprocessImageInput & {
+  kind: 'oneformer-ade20k';
+} & {} & {
+  kind: 'oneformer-ade20k';
+};
+export type PreprocessImageOneFormerCocoInput = PreprocessImageInput & {
+  kind: 'oneformer-coco';
+} & {} & {
+  kind: 'oneformer-coco';
+};
+export type PreprocessImageOpenPoseInput = PreprocessImageInput & {
+  kind: 'openpose';
+} & {
+  detectHand?: boolean;
+  detectBody?: boolean;
+  detectFace?: boolean;
+} & {
+  kind: 'openpose';
+};
+export type PreprocessImageOutput = {
+  blob: ImageBlob;
+};
+export type PreprocessImagePidinetInput = PreprocessImageInput & {
+  kind: 'pidinet';
+} & {
+  safe?: SafeMode;
+} & {
+  kind: 'pidinet';
+};
+export type PreprocessImageRealisticLineartInput = PreprocessImageInput & {
+  kind: 'lineart-realistic';
+} & {
+  coarse?: CoarseMode;
+} & {
+  kind: 'lineart-realistic';
+};
+export type PreprocessImageScribbleInput = PreprocessImageInput & {
+  kind: 'scribble';
+} & {} & {
+  kind: 'scribble';
+};
+export type PreprocessImageScribblePidinetInput = PreprocessImageInput & {
+  kind: 'scribble-pidinet';
+} & {
+  safe?: SafeMode;
+} & {
+  kind: 'scribble-pidinet';
+};
+export type PreprocessImageScribbleXdogInput = PreprocessImageInput & {
+  kind: 'scribble-xdog';
+} & {
+  threshold?: number;
+} & {
+  kind: 'scribble-xdog';
+};
+export type PreprocessImageShuffleInput = PreprocessImageInput & {
+  kind: 'shuffle';
+} & {
+  seed?: number;
+} & {
+  kind: 'shuffle';
+};
+export type PreprocessImageStandardLineartInput = PreprocessImageInput & {
+  kind: 'lineart-standard';
+} & {
+  gaussianSigma?: number;
+  intensityThreshold?: number;
+} & {
+  kind: 'lineart-standard';
+};
+export type PreprocessImageStep = WorkflowStep & {
+  $type: 'preprocessImage';
+} & {
+  input: PreprocessImageInput;
+  output?: PreprocessImageOutput;
+} & {
+  $type: 'preprocessImage';
+};
+export type PreprocessImageStepTemplate = WorkflowStepTemplate & {
+  $type: 'preprocessImage';
+} & {
+  input: PreprocessImageInput;
+} & {
+  $type: 'preprocessImage';
+};
+export type PreprocessImageTeedInput = PreprocessImageInput & {
+  kind: 'teed';
+} & {
+  safeSteps?: number;
+} & {
+  kind: 'teed';
+};
+export type PreprocessImageTileInput = PreprocessImageInput & {
+  kind: 'tile';
+} & {
+  pyrUpIterations?: number;
+} & {
+  kind: 'tile';
+};
+export type PreprocessImageUniFormerInput = PreprocessImageInput & {
+  kind: 'uniformer';
+} & {} & {
+  kind: 'uniformer';
+};
+export type PreprocessImageZoeDepthAnythingInput = PreprocessImageInput & {
+  kind: 'zoe-depth-anything';
+} & {
+  environment?: ZoeDepthEnvironment;
+} & {
+  kind: 'zoe-depth-anything';
+};
+export type PreprocessImageZoeDepthInput = PreprocessImageInput & {
+  kind: 'zoe-depth';
+} & {} & {
+  kind: 'zoe-depth';
+};
 /**
  * Available options for priority.
  */
@@ -978,6 +1884,98 @@ export type ProblemDetails = {
     | (string | null)
     | undefined;
 };
+export type Qwen20bCreateImageGenInput = Qwen20bImageGenInput & {
+  width?: number;
+  height?: number;
+} & {
+  operation: 'createImage';
+};
+export type Qwen20bEditImageGenInput = Qwen20bImageGenInput & {
+  images: Array<string>;
+  readonly width?: number;
+  readonly height?: number;
+} & {
+  operation: 'editImage';
+};
+export type Qwen20bImageGenInput = QwenImageGenInput & {
+  operation: string;
+  diffuserModel?: string;
+  prompt: string;
+  negativePrompt?: string | null;
+  sampleMethod?: SdCppSampleMethod;
+  schedule?: SdCppSchedule;
+  steps?: number;
+  cfgScale?: number;
+  seed?: number | null;
+  quantity?: number;
+} & {
+  model: '20b';
+};
+export type Qwen20bVariantImageGenInput = Qwen20bImageGenInput & {
+  /**
+   * Either A URL, A DataURL or a Base64 string
+   */
+  image: string;
+  strength?: number;
+  readonly width?: number;
+  readonly height?: number;
+} & {
+  operation: 'createVariant';
+};
+/**
+ * AI Toolkit training for Qwen Image models
+ */
+export type QwenAiToolkitTrainingInput = AiToolkitTrainingInput & {} & {
+  ecosystem: 'qwen';
+};
+export type QwenImageGenInput = SdCppImageGenInput & {
+  model: string;
+} & {
+  ecosystem: 'qwen';
+};
+/**
+ * Represents the "for" clause in a repeat step that specifies what to iterate over.
+ */
+export type RepeatForClause = {
+  /**
+   * The dynamic assignment reference to the array to iterate over (e.g., "$stepName").
+   */
+  $ref: string;
+  /**
+   * The path to the array property in the referenced step's output (e.g., "output.frames").
+   */
+  path: string;
+  /**
+   * The variable name to use when referencing the current iteration item in template steps (e.g., "frame").
+   */
+  as: string;
+};
+/**
+ * Represents the input information needed for the Repeat workflow step.
+ */
+export type RepeatInput = {
+  for: RepeatForClause;
+  template: WorkflowStepTemplate;
+};
+/**
+ * Represents the output information returned from the Repeat workflow step.
+ */
+export type RepeatOutput = {
+  steps: Array<WorkflowStep>;
+};
+/**
+ * Resizes an image to a target width while maintaining aspect ratio.
+ */
+export type ResizeTransform = ImageTransform & {
+  type: 'resize';
+} & {
+  /**
+   * Target width in pixels. Height is calculated to maintain aspect ratio.
+   */
+  targetWidth?: number | null;
+} & {
+  type: 'resize';
+};
 /**
  * Details for a specific resource.
  */
@@ -1056,6 +2054,31 @@ export type ResourceInfo = {
    */
   hasNSFWContentRestriction?: boolean;
 };
+/**
+ * AI Toolkit training for Stable Diffusion 1.5 models
+ */
+export type Sd1AiToolkitTrainingInput = AiToolkitTrainingInput & {
+  /**
+   * Learning is performed by putting noise of various strengths on the training image,
+   * but depending on the difference in strength of the noise on which it is placed, learning will be
+   * stable by moving closer to or farther from the learning target.
+   *
+   * Min SNR gamma was introduced to compensate for that. When learning images have little noise,
+   * it may deviate greatly from the target, so try to suppress this jump.
+   */
+  minSnrGamma?: number | null;
+  /**
+   * The primary model to train upon.
+   */
+  model?: string;
+} & {
+  ecosystem: 'sd1';
+};
+export declare const SafeMode: {
+  readonly ENABLE: 'enable';
+  readonly DISABLE: 'disable';
+};
+export type SafeMode = (typeof SafeMode)[keyof typeof SafeMode];
 /**
  * The available options for schedulers used in image generation.
  */
@@ -1090,6 +2113,113 @@ export declare const Scheduler: {
  * The available options for schedulers used in image generation.
  */
 export type Scheduler = (typeof Scheduler)[keyof typeof Scheduler];
+export type SdCppImageGenInput = ImageGenInput & {
+  engine: 'sdcpp';
+} & {
+  ecosystem: string;
+} & {
+  engine: 'sdcpp';
+};
+export declare const SdCppSampleMethod: {
+  readonly EULER: 'euler';
+  readonly HEUN: 'heun';
+  readonly DPM2: 'dpm2';
+  readonly 'DPM++2S_A': 'dpm++2s_a';
+  readonly 'DPM++2M': 'dpm++2m';
+  readonly 'DPM++2MV2': 'dpm++2mv2';
+  readonly IPNDM: 'ipndm';
+  readonly IPNDM_V: 'ipndm_v';
+  readonly DDIM_TRAILING: 'ddim_trailing';
+  readonly EULER_A: 'euler_a';
+  readonly LCM: 'lcm';
+};
+export type SdCppSampleMethod = (typeof SdCppSampleMethod)[keyof typeof SdCppSampleMethod];
+export declare const SdCppSchedule: {
+  readonly SIMPLE: 'simple';
+  readonly DISCRETE: 'discrete';
+  readonly KARRAS: 'karras';
+  readonly EXPONENTIAL: 'exponential';
+  readonly AYS: 'ays';
+};
+export type SdCppSchedule = (typeof SdCppSchedule)[keyof typeof SdCppSchedule];
+/**
+ * AI Toolkit training for Stable Diffusion XL models
+ */
+export type SdxlAiToolkitTrainingInput = AiToolkitTrainingInput & {
+  /**
+   * Learning is performed by putting noise of various strengths on the training image,
+   * but depending on the difference in strength of the noise on which it is placed, learning will be
+   * stable by moving closer to or farther from the learning target.
+   *
+   * Min SNR gamma was introduced to compensate for that. When learning images have little noise,
+   * it may deviate greatly from the target, so try to suppress this jump.
+   */
+  minSnrGamma?: number | null;
+  /**
+   * The primary model to train upon.
+   */
+  model?: string;
+} & {
+  ecosystem: 'sdxl';
+};
+export type SeedreamImageGenInput = ImageGenInput & {
+  engine: 'seedream';
+} & {
+  prompt: string;
+  quantity?: number;
+  width?: number;
+  height?: number;
+  guidanceScale?: number;
+  seed?: number | null;
+  enableSafetyChecker?: boolean;
+  version?: SeedreamVersion;
+  images?: Array<string>;
+} & {
+  engine: 'seedream';
+};
+export declare const SeedreamVersion: {
+  readonly V3: 'v3';
+  readonly V4: 'v4';
+  readonly V4_5: 'v4.5';
+};
+export type SeedreamVersion = (typeof SeedreamVersion)[keyof typeof SeedreamVersion];
+/**
+ * Sora 2 Image-to-Video
+ * FAL Endpoints:
+ * - Standard: https://fal.ai/api/openapi/queue/openapi.json?endpoint_id=fal-ai/sora-2/image-to-video
+ * - Pro: https://fal.ai/api/openapi/queue/openapi.json?endpoint_id=fal-ai/sora-2/image-to-video/pro
+ */
+export type Sora2ImageToVideoInput = SoraVideoGenInput & {
+  images?: Array<string>;
+} & {
+  operation: 'image-to-video';
+};
+/**
+ * Sora 2 Text-to-Video
+ * FAL Endpoints:
+ * - Standard: https://fal.ai/api/openapi/queue/openapi.json?endpoint_id=fal-ai/sora-2/text-to-video
+ * - Pro: https://fal.ai/api/openapi/queue/openapi.json?endpoint_id=fal-ai/sora-2/text-to-video/pro
+ */
+export type Sora2TextToVideoInput = SoraVideoGenInput & {} & {
+  operation: 'text-to-video';
+};
+/**
+ * Base class for Sora 2 video generation (OpenAI's Sora-2 model via FAL)
+ * Since FAL has a one-to-one mapping with OpenAI's Sora API, we don't need a provider layer.
+ * Discriminator: operation (text-to-video or image-to-video)
+ */
+export type SoraVideoGenInput = VideoGenInput & {
+  engine: 'sora';
+} & {
+  operation: string | null;
+  duration?: number;
+  seed?: number | null;
+  resolution?: '720p' | '1080p';
+  aspectRatio?: 'auto' | '16:9' | '9:16';
+  usePro?: boolean;
+} & {
+  engine: 'sora';
+};
 /**
  * Input for an text to image step.
  */
@@ -1157,6 +2287,7 @@ export type TextToImageInput = {
    * An optional engine to use for generation.
    */
   engine?: string | null;
+  outputFormat?: OutputFormat;
 };
 /**
  * Represents the output of a TextToImage workflow step.
@@ -1188,6 +2319,92 @@ export type TextToImageStepTemplate = WorkflowStepTemplate & {
 } & {
   $type: 'textToImage';
 };
+/**
+ * Represents training data in various formats
+ */
+export type TrainingData = {
+  type: string;
+};
+/**
+ * Input for a training step.
+ */
+export type TrainingInput = {
+  engine: string;
+  trainingData: TrainingData;
+  samples?: TrainingInputSamples;
+};
+/**
+ * Sample generation configuration for training workflows
+ */
+export type TrainingInputSamples = {
+  /**
+   * A selection of sample prompts to generate preview outputs during training.
+   */
+  prompts?: Array<string>;
+  /**
+   * An optional negative prompt that will be applied when generating samples
+   */
+  negativePrompt?: string | null;
+};
+/**
+ * The moderation status of the training data
+ */
+export declare const TrainingModerationStatus: {
+  readonly EVALUATING: 'evaluating';
+  readonly UNDER_REVIEW: 'underReview';
+  readonly APPROVED: 'approved';
+  readonly REJECTED: 'rejected';
+};
+/**
+ * The moderation status of the training data
+ */
+export type TrainingModerationStatus =
+  (typeof TrainingModerationStatus)[keyof typeof TrainingModerationStatus];
+/**
+ * Output from a training step.
+ */
+export type TrainingOutput = {
+  moderationStatus?: TrainingModerationStatus;
+  /**
+   * The trained model artifacts for each epoch
+   */
+  epochs?: Array<TrainingOutputEpochResult>;
+};
+/**
+ * Represents the output of a single training epoch
+ */
+export type TrainingOutputEpochResult = {
+  /**
+   * The epoch number (1-based)
+   */
+  epochNumber?: number;
+  model: Blob;
+  /**
+   * Sample outputs (images/videos/audio) generated with this epoch's model
+   */
+  samples?: Array<Blob>;
+};
+/**
+ * Training
+ */
+export type TrainingStep = WorkflowStep & {
+  $type: 'training';
+} & {
+  input: TrainingInput;
+  output?: TrainingOutput;
+} & {
+  $type: 'training';
+};
+/**
+ * Training
+ */
+export type TrainingStepTemplate = WorkflowStepTemplate & {
+  $type: 'training';
+} & {
+  input: TrainingInput;
+} & {
+  $type: 'training';
+};
 /**
  * Transaction information.
  */
@@ -1257,6 +2474,16 @@ export type TranscodeStep = WorkflowStep & {
 } & {
   $type: 'transcode';
 };
+/**
+ * Transcoding
+ */
+export type TranscodeStepTemplate = WorkflowStepTemplate & {
+  $type: 'transcode';
+} & {
+  input: TranscodeInput;
+} & {
+  $type: 'transcode';
+};
 export type TryOnUInput = {
   subjectUrl: string;
   garmentUrl: string;
@@ -1339,6 +2566,11 @@ export declare const Veo3AspectRatio: {
   readonly '1:1': '1:1';
 };
 export type Veo3AspectRatio = (typeof Veo3AspectRatio)[keyof typeof Veo3AspectRatio];
+export declare const Veo3Version: {
+  readonly '3_0': '3.0';
+  readonly '3_1': '3.1';
+};
+export type Veo3Version = (typeof Veo3Version)[keyof typeof Veo3Version];
 export type Veo3VideoGenInput = VideoGenInput & {
   engine: 'veo3';
 } & {
@@ -1350,6 +2582,7 @@ export type Veo3VideoGenInput = VideoGenInput & {
   seed?: number | null;
   fastMode?: boolean;
   images?: Array<string>;
+  version?: Veo3Version;
 } & {
   engine: 'veo3';
 };
@@ -1378,25 +2611,68 @@ export type VideoEnhancementOutput = {
   video: VideoBlob;
 };
 /**
- * Upscale videos and/or interpolate frames
+ * Upscale videos and/or interpolate frames
+ */
+export type VideoEnhancementStep = WorkflowStep & {
+  $type: 'videoEnhancement';
+} & {
+  input: VideoEnhancementInput;
+  output?: VideoEnhancementOutput;
+} & {
+  $type: 'videoEnhancement';
+};
+/**
+ * Upscale videos and/or interpolate frames
+ */
+export type VideoEnhancementStepTemplate = WorkflowStepTemplate & {
+  $type: 'videoEnhancement';
+} & {
+  input: VideoEnhancementInput;
+} & {
+  $type: 'videoEnhancement';
+};
+/**
+ * Represents the input information needed for the VideoFrameExtraction workflow step.
+ */
+export type VideoFrameExtractionInput = {
+  videoUrl: string;
+  frameRate?: number;
+  uniqueThreshold?: number;
+  maxFrames?: number;
+};
+/**
+ * Represents the output from the VideoFrameExtraction workflow step.
+ */
+export type VideoFrameExtractionOutput = {
+  /**
+   * A collection of extracted unique video frames as image blobs.
+   */
+  frames: Array<ImageBlob>;
+  /**
+   * The total number of unique frames extracted from the video.
+   */
+  totalFramesExtracted?: number;
+};
+/**
+ * Video Frame Extraction
  */
-export type VideoEnhancementStep = WorkflowStep & {
-  $type: 'videoEnhancement';
+export type VideoFrameExtractionStep = WorkflowStep & {
+  $type: 'videoFrameExtraction';
 } & {
-  input: VideoEnhancementInput;
-  output?: VideoEnhancementOutput;
+  input: VideoFrameExtractionInput;
+  output?: VideoFrameExtractionOutput;
 } & {
-  $type: 'videoEnhancement';
+  $type: 'videoFrameExtraction';
 };
 /**
- * Upscale videos and/or interpolate frames
+ * Video Frame Extraction
  */
-export type VideoEnhancementStepTemplate = WorkflowStepTemplate & {
-  $type: 'videoEnhancement';
+export type VideoFrameExtractionStepTemplate = WorkflowStepTemplate & {
+  $type: 'videoFrameExtraction';
 } & {
-  input: VideoEnhancementInput;
+  input: VideoFrameExtractionInput;
 } & {
-  $type: 'videoEnhancement';
+  $type: 'videoFrameExtraction';
 };
 export type VideoGenInput = {
   engine: string;
@@ -1430,6 +2706,114 @@ export type VideoGenStepTemplate = WorkflowStepTemplate & {
 } & {
   $type: 'videoGen';
 };
+export type VideoInterpolationInput = {
+  video: string;
+  interpolationFactor?: number;
+  model?: string;
+};
+export type VideoInterpolationOutput = {
+  video: VideoBlob;
+};
+/**
+ * Interpolate videos using VFI Mamba
+ */
+export type VideoInterpolationStep = WorkflowStep & {
+  $type: 'videoInterpolation';
+} & {
+  input: VideoInterpolationInput;
+  output?: VideoInterpolationOutput;
+} & {
+  $type: 'videoInterpolation';
+};
+/**
+ * Interpolate videos using VFI Mamba
+ */
+export type VideoInterpolationStepTemplate = WorkflowStepTemplate & {
+  $type: 'videoInterpolation';
+} & {
+  input: VideoInterpolationInput;
+} & {
+  $type: 'videoInterpolation';
+};
+/**
+ * Represents the input information needed for the VideoMetadata workflow step.
+ */
+export type VideoMetadataInput = {
+  /**
+   * The video file to extract metadata from.
+   */
+  video: string;
+};
+/**
+ * Represents the output information returned from the VideoMetadata workflow step.
+ */
+export type VideoMetadataOutput = {
+  /**
+   * The width of the video in pixels.
+   */
+  width: number;
+  /**
+   * The height of the video in pixels.
+   */
+  height: number;
+  /**
+   * The frame rate of the video in frames per second.
+   */
+  fps: number;
+  /**
+   * The duration of the video.
+   */
+  duration: string;
+};
+/**
+ * Extract metadata from videos including width, height, FPS, and duration
+ */
+export type VideoMetadataStep = WorkflowStep & {
+  $type: 'videoMetadata';
+} & {
+  input: VideoMetadataInput;
+  output?: VideoMetadataOutput;
+} & {
+  $type: 'videoMetadata';
+};
+/**
+ * Extract metadata from videos including width, height, FPS, and duration
+ */
+export type VideoMetadataStepTemplate = WorkflowStepTemplate & {
+  $type: 'videoMetadata';
+} & {
+  input: VideoMetadataInput;
+} & {
+  $type: 'videoMetadata';
+};
+export type VideoUpscalerInput = {
+  video: string;
+  scaleFactor?: number;
+};
+export type VideoUpscalerOutput = {
+  video: VideoBlob;
+};
+/**
+ * Upscale videos using FlashVSR
+ */
+export type VideoUpscalerStep = WorkflowStep & {
+  $type: 'videoUpscaler';
+} & {
+  input: VideoUpscalerInput;
+  output?: VideoUpscalerOutput;
+} & {
+  $type: 'videoUpscaler';
+};
+/**
+ * Upscale videos using FlashVSR
+ */
+export type VideoUpscalerStepTemplate = WorkflowStepTemplate & {
+  $type: 'videoUpscaler';
+} & {
+  input: VideoUpscalerInput;
+} & {
+  $type: 'videoUpscaler';
+};
 export type ViduVideoGenInput = VideoGenInput & {
   engine: 'vidu';
 } & {
@@ -1463,6 +2847,62 @@ export declare const ViduVideoGenStyle: {
   readonly ANIME: 'anime';
 };
 export type ViduVideoGenStyle = (typeof ViduVideoGenStyle)[keyof typeof ViduVideoGenStyle];
+/**
+ * Represents the input information needed for the WDTagging workflow step.
+ */
+export type WdTaggingInput = {
+  /**
+   * The model to use for tagging (e.g., "wd14-vit.v1").
+   */
+  model?: string | null;
+  mediaUrl: string;
+  /**
+   * Optional threshold for tag confidence filtering. Tags below this threshold will be excluded.
+   */
+  threshold?: number | null;
+  /**
+   * Optional prompt to guide the tagging process.
+   */
+  prompt?: string | null;
+};
+/**
+ * Represents the output information returned from the WDTagging workflow step.
+ */
+export type WdTaggingOutput = {
+  /**
+   * The detected tags with their confidence scores.
+   */
+  tags: {
+    [key: string]: number;
+  };
+  /**
+   * The content rating scores (general, sensitive, questionable, explicit).
+   */
+  rating?: {
+    [key: string]: number;
+  } | null;
+};
+/**
+ * WDTagging
+ */
+export type WdTaggingStep = WorkflowStep & {
+  $type: 'wdTagging';
+} & {
+  input: WdTaggingInput;
+  output?: WdTaggingOutput;
+} & {
+  $type: 'wdTagging';
+};
+/**
+ * WDTagging
+ */
+export type WdTaggingStepTemplate = WorkflowStepTemplate & {
+  $type: 'wdTagging';
+} & {
+  input: WdTaggingInput;
+} & {
+  $type: 'wdTagging';
+};
 export type Wan21CivitaiVideoGenInput = Wan21VideoGenInput & {
   width?: number;
   height?: number;
@@ -1499,6 +2939,7 @@ export type Wan225bFalVideoGenInput = Wan225bVideoGenInput & {
   aspectRatio?: '1:1' | '16:9' | '9:16' | 'auto';
   enablePromptExpansion?: boolean;
   useDistill?: boolean;
+  useFastWan?: boolean;
   interpolatorModel?: 'none' | 'film' | 'rife';
   negativePrompt?: string | null;
   enableSafetyChecker?: boolean;
@@ -1555,6 +2996,46 @@ export type Wan22VideoGenInput = WanVideoGenInput & {
 } & {
   version: 'v2.2';
 };
+export type Wan25FalImageGenInput = Wan25ImageGenInput & {
+  operation: string | null;
+} & {
+  provider: 'fal';
+};
+export type Wan25FalImageToImageInput = Wan25FalImageGenInput & {
+  images?: Array<string>;
+} & {
+  operation: 'image-to-image';
+};
+export type Wan25FalImageToVideoInput = Wan25FalVideoGenInput & {
+  images?: Array<string>;
+} & {
+  operation: 'image-to-video';
+};
+export type Wan25FalTextToImageInput = Wan25FalImageGenInput & {} & {
+  operation: 'text-to-image';
+};
+export type Wan25FalTextToVideoInput = Wan25FalVideoGenInput & {} & {
+  operation: 'text-to-video';
+};
+export type Wan25FalVideoGenInput = Wan25VideoGenInput & {
+  operation: string | null;
+  resolution?: '480p' | '720p' | '1080p';
+  aspectRatio?: '16:9' | '9:16' | '1:1';
+  enablePromptExpansion?: boolean;
+  negativePrompt?: string | null;
+} & {
+  provider: 'fal';
+};
+export type Wan25ImageGenInput = WanImageGenInput & {
+  provider: string | null;
+} & {
+  version: 'v2.5';
+};
+export type Wan25VideoGenInput = WanVideoGenInput & {
+  provider: string | null;
+} & {
+  version: 'v2.5';
+};
 export type WanImageGenInput = ImageGenInput & {
   engine: 'wan';
 } & {
@@ -1588,6 +3069,28 @@ export type WanVideoGenInput = VideoGenInput & {
 } & {
   engine: 'wan';
 };
+/**
+ * WebP output format configuration.
+ */
+export type WebpOutputFormat = ImageOutputFormat & {
+  format: 'webp';
+} & {
+  /**
+   * Quality setting for WebP compression (1-100). Only applies when Lossless is false.
+   */
+  quality?: number;
+  /**
+   * When true, uses lossless compression. When false, uses lossy compression with the Quality setting.
+   */
+  lossless?: boolean;
+  /**
+   * Maximum number of frames to include in the output. Set to 1 to extract only the first frame from animated images.
+   * When null, all frames are preserved.
+   */
+  maxFrames?: number | null;
+} & {
+  format: 'webp';
+};
 /**
  * Details of a workflow.
  */
@@ -1646,6 +3149,10 @@ export type Workflow = {
    */
   allowMatureContent?: boolean | null;
   upgradeMode?: WorkflowUpgradeMode;
+  /**
+   * An optional set of currencies to use for this workflow.
+   */
+  currencies?: Array<BuzzClientAccount>;
 };
 /**
  * Details of a callback setup for a workflow.
@@ -1681,6 +3188,10 @@ export type WorkflowCallback = {
     | 'job:expired'
     | 'job:canceled'
   >;
+  /**
+   * Whether to include detailed output (step/workflow results) in the callback payload.
+   */
+  detailed?: boolean | null;
 };
 export type WorkflowCost = {
   /**
@@ -1732,6 +3243,76 @@ export type WorkflowEvent = {
    */
   timestamp?: string;
   $type?: string;
+  details?: WorkflowEventDetails;
+};
+/**
+ * Detailed information about a workflow included in webhook callbacks when detailed mode is enabled.
+ */
+export type WorkflowEventDetails = {
+  /**
+   * Custom metadata associated with the workflow
+   */
+  metadata?: {
+    [key: string]: unknown;
+  } | null;
+  /**
+   * Arguments provided to the workflow
+   */
+  arguments?: {
+    [key: string]: unknown;
+  } | null;
+  /**
+   * When the workflow was created
+   */
+  createdAt?: string;
+  /**
+   * When the workflow completed execution
+   */
+  completedAt?: string | null;
+  /**
+   * When the workflow started execution
+   */
+  startedAt?: string | null;
+  /**
+   * Details about each step in the workflow
+   */
+  steps?: Array<WorkflowEventStepDetails>;
+};
+/**
+ * Detailed information about a workflow step within a workflow event.
+ */
+export type WorkflowEventStepDetails = {
+  /**
+   * The name of the step
+   */
+  name: string;
+  status: WorkflowStatus;
+  /**
+   * When the step started execution
+   */
+  startedAt?: string | null;
+  /**
+   * When the step completed execution
+   */
+  completedAt?: string | null;
+  /**
+   * Custom metadata associated with the step
+   */
+  metadata?: {
+    [key: string]: unknown;
+  } | null;
+  /**
+   * The input configuration for the step
+   */
+  input?: unknown;
+  /**
+   * The output result from the step
+   */
+  output?: unknown;
+  /**
+   * The cost of executing the step
+   */
+  cost?: number | null;
 };
 /**
  * Values available to represent workflow status.
@@ -1803,9 +3384,45 @@ export type WorkflowStepEvent = {
   /**
    * The workflow step's name.
    */
-  stepName: string;
+  name: string;
   status: WorkflowStatus;
   $type?: string;
+  details?: WorkflowStepEventDetails;
+};
+/**
+ * Detailed information about a workflow step included in webhook callbacks when detailed mode is enabled.
+ */
+export type WorkflowStepEventDetails = {
+  /**
+   * When the step started execution
+   */
+  startedAt?: string | null;
+  /**
+   * When the step completed execution
+   */
+  completedAt?: string | null;
+  /**
+   * Estimated progress rate of the step (0.0 to 1.0)
+   */
+  estimatedProgressRate?: number | null;
+  /**
+   * Number of times the step has been retried
+   */
+  retries?: number;
+  /**
+   * Custom metadata associated with the step
+   */
+  metadata?: {
+    [key: string]: unknown;
+  } | null;
+  /**
+   * The input configuration for the step
+   */
+  input?: unknown;
+  /**
+   * The output result from the step
+   */
+  output?: unknown;
 };
 /**
  * Details of a job produced by a workflow step.
@@ -1943,6 +3560,10 @@ export type WorkflowTemplate = {
    */
   allowMatureContent?: boolean | null;
   upgradeMode?: WorkflowUpgradeMode;
+  /**
+   * Limit the currencies that can be used to pay for this workflow.
+   */
+  currencies?: Array<BuzzClientAccount>;
 };
 export type WorkflowTips = {
   /**
@@ -1965,6 +3586,58 @@ export declare const WorkflowUpgradeMode: {
  * Specifies how a workflow should be upgraded when mature content is detected and green or blue buzz was used for payment.
  */
 export type WorkflowUpgradeMode = (typeof WorkflowUpgradeMode)[keyof typeof WorkflowUpgradeMode];
+export type ZImageImageGenInput = SdCppImageGenInput & {
+  model: string;
+} & {
+  ecosystem: 'zImage';
+};
+/**
+ * AI Toolkit training for Z Image Turbo models
+ */
+export type ZImageTurboAiToolkitTrainingInput = AiToolkitTrainingInput & {} & {
+  ecosystem: 'zimageturbo';
+};
+export type ZImageTurboCreateImageGenInput = ZImageTurboImageGenInput & {
+  width?: number;
+  height?: number;
+} & {
+  operation: 'createImage';
+};
+export type ZImageTurboImageGenInput = ZImageImageGenInput & {
+  operation: string;
+  prompt: string;
+  negativePrompt?: string | null;
+  sampleMethod?: SdCppSampleMethod;
+  schedule?: SdCppSchedule;
+  steps?: number;
+  cfgScale?: number;
+  seed?: number | null;
+  quantity?: number;
+} & {
+  model: 'turbo';
+};
+/**
+ * Training data packaged as a zip file
+ */
+export type ZipTrainingData = TrainingData & {
+  type: 'zip';
+} & {
+  /**
+   * AIR pointing to the zip file containing training data
+   */
+  sourceUrl: string;
+  /**
+   * The number of images/frames/items in this training data
+   */
+  count: number;
+} & {
+  type: 'zip';
+};
+export declare const ZoeDepthEnvironment: {
+  readonly INDOOR: 'indoor';
+  readonly OUTDOOR: 'outdoor';
+};
+export type ZoeDepthEnvironment = (typeof ZoeDepthEnvironment)[keyof typeof ZoeDepthEnvironment];
 export type GetBlobData = {
   body?: never;
   path: {
@@ -1990,6 +3663,14 @@ export type GetBlobErrors = {
    * Unauthorized
    */
   401: ProblemDetails;
+  /**
+   * Forbidden
+   */
+  403: ProblemDetails;
+  /**
+   * Not Found
+   */
+  404: ProblemDetails;
 };
 export type GetBlobError = GetBlobErrors[keyof GetBlobErrors];
 export type HeadBlobData = {
@@ -2021,10 +3702,71 @@ export type HeadBlobResponses = {
   204: void;
 };
 export type HeadBlobResponse = HeadBlobResponses[keyof HeadBlobResponses];
+export type GetBlobContentData = {
+  body?: never;
+  path: {
+    /**
+     * The encrypted token containing blob access parameters
+     */
+    encryptedToken: string;
+  };
+  query?: never;
+  url: '/v2/consumer/blobs/content/{encryptedToken}';
+};
+export type GetBlobContentErrors = {
+  /**
+   * Bad Request
+   */
+  400: ProblemDetails;
+  /**
+   * Unauthorized
+   */
+  401: ProblemDetails;
+  /**
+   * Not Found
+   */
+  404: ProblemDetails;
+  /**
+   * Internal Server Error
+   */
+  500: unknown;
+};
+export type GetBlobContentError = GetBlobContentErrors[keyof GetBlobContentErrors];
+export type GetBlobContentResponses = {
+  /**
+   * OK
+   */
+  200: unknown;
+};
+export type GetBlockedContentData = {
+  body?: never;
+  path: {
+    /**
+     * The encrypted token containing blocked content parameters
+     */
+    encryptedToken: string;
+  };
+  query?: never;
+  url: '/v2/consumer/blobs/blocked/{encryptedToken}';
+};
+export type GetBlockedContentErrors = {
+  /**
+   * Unauthorized
+   */
+  401: ProblemDetails;
+  /**
+   * Forbidden
+   */
+  403: ProblemDetails;
+};
+export type GetBlockedContentError = GetBlockedContentErrors[keyof GetBlockedContentErrors];
 export type InvokeAgeClassificationStepTemplateData = {
   body?: AgeClassificationInput;
   path?: never;
-  query?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
   url: '/v2/consumer/recipes/ageClassification';
 };
 export type InvokeAgeClassificationStepTemplateErrors = {
@@ -2050,7 +3792,10 @@ export type InvokeAgeClassificationStepTemplateResponse =
 export type InvokeComfyStepTemplateData = {
   body?: ComfyInput;
   path?: never;
-  query?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
   url: '/v2/consumer/recipes/comfy';
 };
 export type InvokeComfyStepTemplateErrors = {
@@ -2073,10 +3818,42 @@ export type InvokeComfyStepTemplateResponses = {
 };
 export type InvokeComfyStepTemplateResponse =
   InvokeComfyStepTemplateResponses[keyof InvokeComfyStepTemplateResponses];
+export type InvokeConvertImageStepTemplateData = {
+  body?: ConvertImageInput;
+  path?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
+  url: '/v2/consumer/recipes/convertImage';
+};
+export type InvokeConvertImageStepTemplateErrors = {
+  /**
+   * Bad Request
+   */
+  400: ProblemDetails;
+  /**
+   * Unauthorized
+   */
+  401: ProblemDetails;
+};
+export type InvokeConvertImageStepTemplateError =
+  InvokeConvertImageStepTemplateErrors[keyof InvokeConvertImageStepTemplateErrors];
+export type InvokeConvertImageStepTemplateResponses = {
+  /**
+   * OK
+   */
+  200: ConvertImageOutput;
+};
+export type InvokeConvertImageStepTemplateResponse =
+  InvokeConvertImageStepTemplateResponses[keyof InvokeConvertImageStepTemplateResponses];
 export type InvokeEchoStepTemplateData = {
   body?: EchoInput;
   path?: never;
-  query?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
   url: '/v2/consumer/recipes/echo';
 };
 export type InvokeEchoStepTemplateErrors = {
@@ -2102,7 +3879,10 @@ export type InvokeEchoStepTemplateResponse =
 export type InvokeImageGenStepTemplateData = {
   body?: ImageGenInput;
   path?: never;
-  query?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
   url: '/v2/consumer/recipes/imageGen';
 };
 export type InvokeImageGenStepTemplateErrors = {
@@ -2128,7 +3908,10 @@ export type InvokeImageGenStepTemplateResponse =
 export type InvokeImageResourceTrainingStepTemplateData = {
   body?: ImageResourceTrainingInput;
   path?: never;
-  query?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
   url: '/v2/consumer/recipes/imageResourceTraining';
 };
 export type InvokeImageResourceTrainingStepTemplateErrors = {
@@ -2154,7 +3937,10 @@ export type InvokeImageResourceTrainingStepTemplateResponse =
 export type InvokeImageUploadStepTemplateData = {
   body?: string;
   path?: never;
-  query?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
   url: '/v2/consumer/recipes/imageUpload';
 };
 export type InvokeImageUploadStepTemplateErrors = {
@@ -2177,10 +3963,129 @@ export type InvokeImageUploadStepTemplateResponses = {
 };
 export type InvokeImageUploadStepTemplateResponse =
   InvokeImageUploadStepTemplateResponses[keyof InvokeImageUploadStepTemplateResponses];
+export type InvokeImageUpscalerStepTemplateData = {
+  body?: ImageUpscalerInput;
+  path?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
+  url: '/v2/consumer/recipes/imageUpscaler';
+};
+export type InvokeImageUpscalerStepTemplateErrors = {
+  /**
+   * Bad Request
+   */
+  400: ProblemDetails;
+  /**
+   * Unauthorized
+   */
+  401: ProblemDetails;
+};
+export type InvokeImageUpscalerStepTemplateError =
+  InvokeImageUpscalerStepTemplateErrors[keyof InvokeImageUpscalerStepTemplateErrors];
+export type InvokeImageUpscalerStepTemplateResponses = {
+  /**
+   * OK
+   */
+  200: ImageUpscalerOutput;
+};
+export type InvokeImageUpscalerStepTemplateResponse =
+  InvokeImageUpscalerStepTemplateResponses[keyof InvokeImageUpscalerStepTemplateResponses];
+export type InvokeMediaHashStepTemplateData = {
+  body?: MediaHashInput;
+  path?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
+  url: '/v2/consumer/recipes/mediaHash';
+};
+export type InvokeMediaHashStepTemplateErrors = {
+  /**
+   * Bad Request
+   */
+  400: ProblemDetails;
+  /**
+   * Unauthorized
+   */
+  401: ProblemDetails;
+};
+export type InvokeMediaHashStepTemplateError =
+  InvokeMediaHashStepTemplateErrors[keyof InvokeMediaHashStepTemplateErrors];
+export type InvokeMediaHashStepTemplateResponses = {
+  /**
+   * OK
+   */
+  200: MediaHashOutput;
+};
+export type InvokeMediaHashStepTemplateResponse =
+  InvokeMediaHashStepTemplateResponses[keyof InvokeMediaHashStepTemplateResponses];
+export type InvokeMediaRatingStepTemplateData = {
+  body?: MediaRatingInput;
+  path?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
+  url: '/v2/consumer/recipes/mediaRating';
+};
+export type InvokeMediaRatingStepTemplateErrors = {
+  /**
+   * Bad Request
+   */
+  400: ProblemDetails;
+  /**
+   * Unauthorized
+   */
+  401: ProblemDetails;
+};
+export type InvokeMediaRatingStepTemplateError =
+  InvokeMediaRatingStepTemplateErrors[keyof InvokeMediaRatingStepTemplateErrors];
+export type InvokeMediaRatingStepTemplateResponses = {
+  /**
+   * OK
+   */
+  200: MediaRatingOutput;
+};
+export type InvokeMediaRatingStepTemplateResponse =
+  InvokeMediaRatingStepTemplateResponses[keyof InvokeMediaRatingStepTemplateResponses];
+export type InvokePreprocessImageStepTemplateData = {
+  body?: PreprocessImageInput;
+  path?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
+  url: '/v2/consumer/recipes/preprocessImage';
+};
+export type InvokePreprocessImageStepTemplateErrors = {
+  /**
+   * Bad Request
+   */
+  400: ProblemDetails;
+  /**
+   * Unauthorized
+   */
+  401: ProblemDetails;
+};
+export type InvokePreprocessImageStepTemplateError =
+  InvokePreprocessImageStepTemplateErrors[keyof InvokePreprocessImageStepTemplateErrors];
+export type InvokePreprocessImageStepTemplateResponses = {
+  /**
+   * OK
+   */
+  200: PreprocessImageOutput;
+};
+export type InvokePreprocessImageStepTemplateResponse =
+  InvokePreprocessImageStepTemplateResponses[keyof InvokePreprocessImageStepTemplateResponses];
 export type InvokeTextToImageStepTemplateData = {
   body?: TextToImageInput;
   path?: never;
-  query?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
   url: '/v2/consumer/recipes/textToImage';
 };
 export type InvokeTextToImageStepTemplateErrors = {
@@ -2203,10 +4108,42 @@ export type InvokeTextToImageStepTemplateResponses = {
 };
 export type InvokeTextToImageStepTemplateResponse =
   InvokeTextToImageStepTemplateResponses[keyof InvokeTextToImageStepTemplateResponses];
+export type InvokeTrainingStepTemplateData = {
+  body?: TrainingInput;
+  path?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
+  url: '/v2/consumer/recipes/training';
+};
+export type InvokeTrainingStepTemplateErrors = {
+  /**
+   * Bad Request
+   */
+  400: ProblemDetails;
+  /**
+   * Unauthorized
+   */
+  401: ProblemDetails;
+};
+export type InvokeTrainingStepTemplateError =
+  InvokeTrainingStepTemplateErrors[keyof InvokeTrainingStepTemplateErrors];
+export type InvokeTrainingStepTemplateResponses = {
+  /**
+   * OK
+   */
+  200: TrainingOutput;
+};
+export type InvokeTrainingStepTemplateResponse =
+  InvokeTrainingStepTemplateResponses[keyof InvokeTrainingStepTemplateResponses];
 export type InvokeVideoEnhancementStepTemplateData = {
   body?: VideoEnhancementInput;
   path?: never;
-  query?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
   url: '/v2/consumer/recipes/videoEnhancement';
 };
 export type InvokeVideoEnhancementStepTemplateErrors = {
@@ -2229,10 +4166,42 @@ export type InvokeVideoEnhancementStepTemplateResponses = {
 };
 export type InvokeVideoEnhancementStepTemplateResponse =
   InvokeVideoEnhancementStepTemplateResponses[keyof InvokeVideoEnhancementStepTemplateResponses];
+export type InvokeVideoFrameExtractionStepTemplateData = {
+  body?: VideoFrameExtractionInput;
+  path?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
+  url: '/v2/consumer/recipes/videoFrameExtraction';
+};
+export type InvokeVideoFrameExtractionStepTemplateErrors = {
+  /**
+   * Bad Request
+   */
+  400: ProblemDetails;
+  /**
+   * Unauthorized
+   */
+  401: ProblemDetails;
+};
+export type InvokeVideoFrameExtractionStepTemplateError =
+  InvokeVideoFrameExtractionStepTemplateErrors[keyof InvokeVideoFrameExtractionStepTemplateErrors];
+export type InvokeVideoFrameExtractionStepTemplateResponses = {
+  /**
+   * OK
+   */
+  200: VideoFrameExtractionOutput;
+};
+export type InvokeVideoFrameExtractionStepTemplateResponse =
+  InvokeVideoFrameExtractionStepTemplateResponses[keyof InvokeVideoFrameExtractionStepTemplateResponses];
 export type InvokeVideoGenStepTemplateData = {
   body?: VideoGenInput;
   path?: never;
-  query?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
   url: '/v2/consumer/recipes/videoGen';
 };
 export type InvokeVideoGenStepTemplateErrors = {
@@ -2255,6 +4224,122 @@ export type InvokeVideoGenStepTemplateResponses = {
 };
 export type InvokeVideoGenStepTemplateResponse =
   InvokeVideoGenStepTemplateResponses[keyof InvokeVideoGenStepTemplateResponses];
+export type InvokeVideoInterpolationStepTemplateData = {
+  body?: VideoInterpolationInput;
+  path?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
+  url: '/v2/consumer/recipes/videoInterpolation';
+};
+export type InvokeVideoInterpolationStepTemplateErrors = {
+  /**
+   * Bad Request
+   */
+  400: ProblemDetails;
+  /**
+   * Unauthorized
+   */
+  401: ProblemDetails;
+};
+export type InvokeVideoInterpolationStepTemplateError =
+  InvokeVideoInterpolationStepTemplateErrors[keyof InvokeVideoInterpolationStepTemplateErrors];
+export type InvokeVideoInterpolationStepTemplateResponses = {
+  /**
+   * OK
+   */
+  200: VideoInterpolationOutput;
+};
+export type InvokeVideoInterpolationStepTemplateResponse =
+  InvokeVideoInterpolationStepTemplateResponses[keyof InvokeVideoInterpolationStepTemplateResponses];
+export type InvokeVideoMetadataStepTemplateData = {
+  body?: VideoMetadataInput;
+  path?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
+  url: '/v2/consumer/recipes/videoMetadata';
+};
+export type InvokeVideoMetadataStepTemplateErrors = {
+  /**
+   * Bad Request
+   */
+  400: ProblemDetails;
+  /**
+   * Unauthorized
+   */
+  401: ProblemDetails;
+};
+export type InvokeVideoMetadataStepTemplateError =
+  InvokeVideoMetadataStepTemplateErrors[keyof InvokeVideoMetadataStepTemplateErrors];
+export type InvokeVideoMetadataStepTemplateResponses = {
+  /**
+   * OK
+   */
+  200: VideoMetadataOutput;
+};
+export type InvokeVideoMetadataStepTemplateResponse =
+  InvokeVideoMetadataStepTemplateResponses[keyof InvokeVideoMetadataStepTemplateResponses];
+export type InvokeVideoUpscalerStepTemplateData = {
+  body?: VideoUpscalerInput;
+  path?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
+  url: '/v2/consumer/recipes/videoUpscaler';
+};
+export type InvokeVideoUpscalerStepTemplateErrors = {
+  /**
+   * Bad Request
+   */
+  400: ProblemDetails;
+  /**
+   * Unauthorized
+   */
+  401: ProblemDetails;
+};
+export type InvokeVideoUpscalerStepTemplateError =
+  InvokeVideoUpscalerStepTemplateErrors[keyof InvokeVideoUpscalerStepTemplateErrors];
+export type InvokeVideoUpscalerStepTemplateResponses = {
+  /**
+   * OK
+   */
+  200: VideoUpscalerOutput;
+};
+export type InvokeVideoUpscalerStepTemplateResponse =
+  InvokeVideoUpscalerStepTemplateResponses[keyof InvokeVideoUpscalerStepTemplateResponses];
+export type InvokeWdTaggingStepTemplateData = {
+  body?: WdTaggingInput;
+  path?: never;
+  query?: {
+    experimental?: boolean;
+    allowMatureContent?: boolean;
+  };
+  url: '/v2/consumer/recipes/wdTagging';
+};
+export type InvokeWdTaggingStepTemplateErrors = {
+  /**
+   * Bad Request
+   */
+  400: ProblemDetails;
+  /**
+   * Unauthorized
+   */
+  401: ProblemDetails;
+};
+export type InvokeWdTaggingStepTemplateError =
+  InvokeWdTaggingStepTemplateErrors[keyof InvokeWdTaggingStepTemplateErrors];
+export type InvokeWdTaggingStepTemplateResponses = {
+  /**
+   * OK
+   */
+  200: WdTaggingOutput;
+};
+export type InvokeWdTaggingStepTemplateResponse =
+  InvokeWdTaggingStepTemplateResponses[keyof InvokeWdTaggingStepTemplateResponses];
 export type InvalidateResourceData = {
   body?: never;
   path: {