chore(ui): regen api client

invokeai/frontend/web/src/services/api/models/CannyImageProcessorInvocation.ts

@@ -0,0 +1,29 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+import type { ImageField } from './ImageField';
+
+/**
+ * Canny edge detection for ControlNet
+ */
+export type CannyImageProcessorInvocation = {
+  /**
+   * The id of this node. Must be unique among all nodes.
+   */
+  id: string;
+  type?: 'canny_image_processor';
+  /**
+   * image to process
+   */
+  image?: ImageField;
+  /**
+   * low threshold of Canny pixel gradient
+   */
+  low_threshold?: number;
+  /**
+   * high threshold of Canny pixel gradient
+   */
+  high_threshold?: number;
+};
+

invokeai/frontend/web/src/services/api/models/ContentShuffleImageProcessorInvocation.ts

@@ -0,0 +1,41 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+import type { ImageField } from './ImageField';
+
+/**
+ * Applies content shuffle processing to image
+ */
+export type ContentShuffleImageProcessorInvocation = {
+  /**
+   * The id of this node. Must be unique among all nodes.
+   */
+  id: string;
+  type?: 'content_shuffle_image_processor';
+  /**
+   * image to process
+   */
+  image?: ImageField;
+  /**
+   * pixel resolution for edge detection
+   */
+  detect_resolution?: number;
+  /**
+   * pixel resolution for output image
+   */
+  image_resolution?: number;
+  /**
+   * content shuffle h parameter
+   */
+  'h'?: number;
+  /**
+   * content shuffle w parameter
+   */
+  'w'?: number;
+  /**
+   * cont
+   */
+  'f'?: number;
+};
+

invokeai/frontend/web/src/services/api/models/ControlField.ts

@@ -0,0 +1,29 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+import type { ImageField } from './ImageField';
+
+export type ControlField = {
+  /**
+   * processed image
+   */
+  image: ImageField;
+  /**
+   * control model used
+   */
+  control_model: string;
+  /**
+   * weight given to controlnet
+   */
+  control_weight: number;
+  /**
+   * % of total steps at which controlnet is first applied
+   */
+  begin_step_percent: number;
+  /**
+   * % of total steps at which controlnet is last applied
+   */
+  end_step_percent: number;
+};
+

invokeai/frontend/web/src/services/api/models/ControlNetInvocation.ts

@@ -0,0 +1,37 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+import type { ImageField } from './ImageField';
+
+/**
+ * Collects ControlNet info to pass to other nodes
+ */
+export type ControlNetInvocation = {
+  /**
+   * The id of this node. Must be unique among all nodes.
+   */
+  id: string;
+  type?: 'controlnet';
+  /**
+   * image to process
+   */
+  image?: ImageField;
+  /**
+   * control model used
+   */
+  control_model?: 'lllyasviel/sd-controlnet-canny' | 'lllyasviel/sd-controlnet-depth' | 'lllyasviel/sd-controlnet-hed' | 'lllyasviel/sd-controlnet-seg' | 'lllyasviel/sd-controlnet-openpose' | 'lllyasviel/sd-controlnet-scribble' | 'lllyasviel/sd-controlnet-normal' | 'lllyasviel/sd-controlnet-mlsd' | 'lllyasviel/control_v11p_sd15_canny' | 'lllyasviel/control_v11p_sd15_openpose' | 'lllyasviel/control_v11p_sd15_seg' | 'lllyasviel/control_v11f1p_sd15_depth' | 'lllyasviel/control_v11p_sd15_normalbae' | 'lllyasviel/control_v11p_sd15_scribble' | 'lllyasviel/control_v11p_sd15_mlsd' | 'lllyasviel/control_v11p_sd15_softedge' | 'lllyasviel/control_v11p_sd15s2_lineart_anime' | 'lllyasviel/control_v11p_sd15_lineart' | 'lllyasviel/control_v11p_sd15_inpaint' | 'lllyasviel/control_v11e_sd15_shuffle' | 'lllyasviel/control_v11e_sd15_ip2p' | 'lllyasviel/control_v11f1e_sd15_tile' | 'thibaud/controlnet-sd21-openpose-diffusers' | 'thibaud/controlnet-sd21-canny-diffusers' | 'thibaud/controlnet-sd21-depth-diffusers' | 'thibaud/controlnet-sd21-scribble-diffusers' | 'thibaud/controlnet-sd21-hed-diffusers' | 'thibaud/controlnet-sd21-zoedepth-diffusers' | 'thibaud/controlnet-sd21-color-diffusers' | 'thibaud/controlnet-sd21-openposev2-diffusers' | 'thibaud/controlnet-sd21-lineart-diffusers' | 'thibaud/controlnet-sd21-normalbae-diffusers' | 'thibaud/controlnet-sd21-ade20k-diffusers' | 'CrucibleAI/ControlNetMediaPipeFace';
+  /**
+   * weight given to controlnet
+   */
+  control_weight?: number;
+  /**
+   * % of total steps at which controlnet is first applied
+   */
+  begin_step_percent?: number;
+  /**
+   * % of total steps at which controlnet is last applied
+   */
+  end_step_percent?: number;
+};
+

invokeai/frontend/web/src/services/api/models/ControlOutput.ts

@@ -0,0 +1,17 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+import type { ControlField } from './ControlField';
+
+/**
+ * node output for ControlNet info
+ */
+export type ControlOutput = {
+  type?: 'control_output';
+  /**
+   * The control info dict
+   */
+  control?: ControlField;
+};
+

invokeai/frontend/web/src/services/api/models/HedImageprocessorInvocation.ts

@@ -0,0 +1,33 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+import type { ImageField } from './ImageField';
+
+/**
+ * Applies HED edge detection to image
+ */
+export type HedImageprocessorInvocation = {
+  /**
+   * The id of this node. Must be unique among all nodes.
+   */
+  id: string;
+  type?: 'hed_image_processor';
+  /**
+   * image to process
+   */
+  image?: ImageField;
+  /**
+   * pixel resolution for edge detection
+   */
+  detect_resolution?: number;
+  /**
+   * pixel resolution for output image
+   */
+  image_resolution?: number;
+  /**
+   * whether to use scribble mode
+   */
+  scribble?: boolean;
+};
+

invokeai/frontend/web/src/services/api/models/ImageProcessorInvocation.ts

@@ -0,0 +1,21 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+import type { ImageField } from './ImageField';
+
+/**
+ * Base class for invocations that preprocess images for ControlNet
+ */
+export type ImageProcessorInvocation = {
+  /**
+   * The id of this node. Must be unique among all nodes.
+   */
+  id: string;
+  type?: 'image_processor';
+  /**
+   * image to process
+   */
+  image?: ImageField;
+};
+

invokeai/frontend/web/src/services/api/models/ImageToImageInvocation.ts

@@ -49,6 +49,18 @@ export type ImageToImageInvocation = {
    * The model to use (currently ignored)
    */
   model?: string;
+  /**
+   * Whether or not to produce progress images during generation
+   */
+  progress_images?: boolean;
+  /**
+   * The control model to use
+   */
+  control_model?: string;
+  /**
+   * The processed control image
+   */
+  control_image?: ImageField;
   /**
    * The input image
    */

invokeai/frontend/web/src/services/api/models/InpaintInvocation.ts

@@ -50,6 +50,18 @@ export type InpaintInvocation = {
    * The model to use (currently ignored)
    */
   model?: string;
+  /**
+   * Whether or not to produce progress images during generation
+   */
+  progress_images?: boolean;
+  /**
+   * The control model to use
+   */
+  control_model?: string;
+  /**
+   * The processed control image
+   */
+  control_image?: ImageField;
   /**
    * The input image
    */

invokeai/frontend/web/src/services/api/models/LineartAnimeImageProcessorInvocation.ts

@@ -0,0 +1,29 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+import type { ImageField } from './ImageField';
+
+/**
+ * Applies line art anime processing to image
+ */
+export type LineartAnimeImageProcessorInvocation = {
+  /**
+   * The id of this node. Must be unique among all nodes.
+   */
+  id: string;
+  type?: 'lineart_anime_image_processor';
+  /**
+   * image to process
+   */
+  image?: ImageField;
+  /**
+   * pixel resolution for edge detection
+   */
+  detect_resolution?: number;
+  /**
+   * pixel resolution for output image
+   */
+  image_resolution?: number;
+};
+

invokeai/frontend/web/src/services/api/models/LineartImageProcessorInvocation.ts

@@ -0,0 +1,33 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+import type { ImageField } from './ImageField';
+
+/**
+ * Applies line art processing to image
+ */
+export type LineartImageProcessorInvocation = {
+  /**
+   * The id of this node. Must be unique among all nodes.
+   */
+  id: string;
+  type?: 'lineart_image_processor';
+  /**
+   * image to process
+   */
+  image?: ImageField;
+  /**
+   * pixel resolution for edge detection
+   */
+  detect_resolution?: number;
+  /**
+   * pixel resolution for output image
+   */
+  image_resolution?: number;
+  /**
+   * whether to use coarse mode
+   */
+  coarse?: boolean;
+};
+

invokeai/frontend/web/src/services/api/models/MidasDepthImageProcessorInvocation.ts

@@ -0,0 +1,29 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+import type { ImageField } from './ImageField';
+
+/**
+ * Applies Midas depth processing to image
+ */
+export type MidasDepthImageProcessorInvocation = {
+  /**
+   * The id of this node. Must be unique among all nodes.
+   */
+  id: string;
+  type?: 'midas_depth_image_processor';
+  /**
+   * image to process
+   */
+  image?: ImageField;
+  /**
+   * Midas parameter a = amult * PI
+   */
+  a_mult?: number;
+  /**
+   * Midas parameter bg_th
+   */
+  bg_th?: number;
+};
+

invokeai/frontend/web/src/services/api/models/MlsdImageProcessorInvocation.ts

@@ -0,0 +1,37 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+import type { ImageField } from './ImageField';
+
+/**
+ * Applies MLSD processing to image
+ */
+export type MlsdImageProcessorInvocation = {
+  /**
+   * The id of this node. Must be unique among all nodes.
+   */
+  id: string;
+  type?: 'mlsd_image_processor';
+  /**
+   * image to process
+   */
+  image?: ImageField;
+  /**
+   * pixel resolution for edge detection
+   */
+  detect_resolution?: number;
+  /**
+   * pixel resolution for output image
+   */
+  image_resolution?: number;
+  /**
+   * MLSD parameter thr_v
+   */
+  thr_v?: number;
+  /**
+   * MLSD parameter thr_d
+   */
+  thr_d?: number;
+};
+

invokeai/frontend/web/src/services/api/models/NormalbaeImageProcessorInvocation.ts

@@ -0,0 +1,29 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+import type { ImageField } from './ImageField';
+
+/**
+ * Applies NormalBae processing to image
+ */
+export type NormalbaeImageProcessorInvocation = {
+  /**
+   * The id of this node. Must be unique among all nodes.
+   */
+  id: string;
+  type?: 'normalbae_image_processor';
+  /**
+   * image to process
+   */
+  image?: ImageField;
+  /**
+   * pixel resolution for edge detection
+   */
+  detect_resolution?: number;
+  /**
+   * pixel resolution for output image
+   */
+  image_resolution?: number;
+};
+

invokeai/frontend/web/src/services/api/models/OpenposeImageProcessorInvocation.ts

@@ -0,0 +1,33 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+import type { ImageField } from './ImageField';
+
+/**
+ * Applies Openpose processing to image
+ */
+export type OpenposeImageProcessorInvocation = {
+  /**
+   * The id of this node. Must be unique among all nodes.
+   */
+  id: string;
+  type?: 'openpose_image_processor';
+  /**
+   * image to process
+   */
+  image?: ImageField;
+  /**
+   * whether to use hands and face mode
+   */
+  hand_and_face?: boolean;
+  /**
+   * pixel resolution for edge detection
+   */
+  detect_resolution?: number;
+  /**
+   * pixel resolution for output image
+   */
+  image_resolution?: number;
+};
+

invokeai/frontend/web/src/services/api/models/PidiImageProcessorInvocation.ts

@@ -0,0 +1,37 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+
+import type { ImageField } from './ImageField';
+
+/**
+ * Applies PIDI processing to image
+ */
+export type PidiImageProcessorInvocation = {
+  /**
+   * The id of this node. Must be unique among all nodes.
+   */
+  id: string;
+  type?: 'pidi_image_processor';
+  /**
+   * image to process
+   */
+  image?: ImageField;
+  /**
+   * pixel resolution for edge detection
+   */
+  detect_resolution?: number;
+  /**
+   * pixel resolution for output image
+   */
+  image_resolution?: number;
+  /**
+   * whether to use safe mode
+   */
+  safe?: boolean;
+  /**
+   * whether to use scribble mode
+   */
+  scribble?: boolean;
+};
+

invokeai/frontend/web/src/services/api/models/TextToImageInvocation.ts

@@ -2,6 +2,8 @@
 /* tslint:disable */
 /* eslint-disable */
 
+import type { ImageField } from './ImageField';
+
 /**
  * Generates an image using text2img.
  */
@@ -47,5 +49,17 @@ export type TextToImageInvocation = {
    * The model to use (currently ignored)
    */
   model?: string;
+  /**
+   * Whether or not to produce progress images during generation
+   */
+  progress_images?: boolean;
+  /**
+   * The control model to use
+   */
+  control_model?: string;
+  /**
+   * The processed control image
+   */
+  control_image?: ImageField;
 };
 

invokeai/frontend/web/src/services/api/schemas/$CannyImageProcessorInvocation.ts

@@ -0,0 +1,31 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $CannyImageProcessorInvocation = {
+  description: `Canny edge detection for ControlNet`,
+  properties: {
+    id: {
+      type: 'string',
+      description: `The id of this node. Must be unique among all nodes.`,
+      isRequired: true,
+    },
+    type: {
+      type: 'Enum',
+    },
+    image: {
+      type: 'all-of',
+      description: `image to process`,
+      contains: [{
+        type: 'ImageField',
+      }],
+    },
+    low_threshold: {
+      type: 'number',
+      description: `low threshold of Canny pixel gradient`,
+    },
+    high_threshold: {
+      type: 'number',
+      description: `high threshold of Canny pixel gradient`,
+    },
+  },
+} as const;

invokeai/frontend/web/src/services/api/schemas/$ContentShuffleImageProcessorInvocation.ts

@@ -0,0 +1,43 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $ContentShuffleImageProcessorInvocation = {
+  description: `Applies content shuffle processing to image`,
+  properties: {
+    id: {
+      type: 'string',
+      description: `The id of this node. Must be unique among all nodes.`,
+      isRequired: true,
+    },
+    type: {
+      type: 'Enum',
+    },
+    image: {
+      type: 'all-of',
+      description: `image to process`,
+      contains: [{
+        type: 'ImageField',
+      }],
+    },
+    detect_resolution: {
+      type: 'number',
+      description: `pixel resolution for edge detection`,
+    },
+    image_resolution: {
+      type: 'number',
+      description: `pixel resolution for output image`,
+    },
+    'h': {
+      type: 'number',
+      description: `content shuffle h parameter`,
+    },
+    'w': {
+      type: 'number',
+      description: `content shuffle w parameter`,
+    },
+    'f': {
+      type: 'number',
+      description: `cont`,
+    },
+  },
+} as const;

invokeai/frontend/web/src/services/api/schemas/$ControlField.ts

@@ -0,0 +1,37 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $ControlField = {
+  properties: {
+    image: {
+      type: 'all-of',
+      description: `processed image`,
+      contains: [{
+        type: 'ImageField',
+      }],
+      isRequired: true,
+    },
+    control_model: {
+      type: 'string',
+      description: `control model used`,
+      isRequired: true,
+    },
+    control_weight: {
+      type: 'number',
+      description: `weight given to controlnet`,
+      isRequired: true,
+    },
+    begin_step_percent: {
+      type: 'number',
+      description: `% of total steps at which controlnet is first applied`,
+      isRequired: true,
+      maximum: 1,
+    },
+    end_step_percent: {
+      type: 'number',
+      description: `% of total steps at which controlnet is last applied`,
+      isRequired: true,
+      maximum: 1,
+    },
+  },
+} as const;

invokeai/frontend/web/src/services/api/schemas/$ControlNetInvocation.ts

@@ -0,0 +1,41 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $ControlNetInvocation = {
+  description: `Collects ControlNet info to pass to other nodes`,
+  properties: {
+    id: {
+      type: 'string',
+      description: `The id of this node. Must be unique among all nodes.`,
+      isRequired: true,
+    },
+    type: {
+      type: 'Enum',
+    },
+    image: {
+      type: 'all-of',
+      description: `image to process`,
+      contains: [{
+        type: 'ImageField',
+      }],
+    },
+    control_model: {
+      type: 'Enum',
+    },
+    control_weight: {
+      type: 'number',
+      description: `weight given to controlnet`,
+      maximum: 1,
+    },
+    begin_step_percent: {
+      type: 'number',
+      description: `% of total steps at which controlnet is first applied`,
+      maximum: 1,
+    },
+    end_step_percent: {
+      type: 'number',
+      description: `% of total steps at which controlnet is last applied`,
+      maximum: 1,
+    },
+  },
+} as const;

invokeai/frontend/web/src/services/api/schemas/$ControlOutput.ts

@@ -0,0 +1,18 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $ControlOutput = {
+  description: `node output for ControlNet info`,
+  properties: {
+    type: {
+      type: 'Enum',
+    },
+    control: {
+      type: 'all-of',
+      description: `The control info dict`,
+      contains: [{
+        type: 'ControlField',
+      }],
+    },
+  },
+} as const;

invokeai/frontend/web/src/services/api/schemas/$HedImageprocessorInvocation.ts

@@ -0,0 +1,35 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $HedImageprocessorInvocation = {
+  description: `Applies HED edge detection to image`,
+  properties: {
+    id: {
+      type: 'string',
+      description: `The id of this node. Must be unique among all nodes.`,
+      isRequired: true,
+    },
+    type: {
+      type: 'Enum',
+    },
+    image: {
+      type: 'all-of',
+      description: `image to process`,
+      contains: [{
+        type: 'ImageField',
+      }],
+    },
+    detect_resolution: {
+      type: 'number',
+      description: `pixel resolution for edge detection`,
+    },
+    image_resolution: {
+      type: 'number',
+      description: `pixel resolution for output image`,
+    },
+    scribble: {
+      type: 'boolean',
+      description: `whether to use scribble mode`,
+    },
+  },
+} as const;

invokeai/frontend/web/src/services/api/schemas/$ImageProcessorInvocation.ts

@@ -0,0 +1,23 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $ImageProcessorInvocation = {
+  description: `Base class for invocations that preprocess images for ControlNet`,
+  properties: {
+    id: {
+      type: 'string',
+      description: `The id of this node. Must be unique among all nodes.`,
+      isRequired: true,
+    },
+    type: {
+      type: 'Enum',
+    },
+    image: {
+      type: 'all-of',
+      description: `image to process`,
+      contains: [{
+        type: 'ImageField',
+      }],
+    },
+  },
+} as const;

invokeai/frontend/web/src/services/api/schemas/$LineartAnimeImageProcessorInvocation.ts

@@ -0,0 +1,31 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $LineartAnimeImageProcessorInvocation = {
+  description: `Applies line art anime processing to image`,
+  properties: {
+    id: {
+      type: 'string',
+      description: `The id of this node. Must be unique among all nodes.`,
+      isRequired: true,
+    },
+    type: {
+      type: 'Enum',
+    },
+    image: {
+      type: 'all-of',
+      description: `image to process`,
+      contains: [{
+        type: 'ImageField',
+      }],
+    },
+    detect_resolution: {
+      type: 'number',
+      description: `pixel resolution for edge detection`,
+    },
+    image_resolution: {
+      type: 'number',
+      description: `pixel resolution for output image`,
+    },
+  },
+} as const;

invokeai/frontend/web/src/services/api/schemas/$LineartImageProcessorInvocation.ts

@@ -0,0 +1,35 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $LineartImageProcessorInvocation = {
+  description: `Applies line art processing to image`,
+  properties: {
+    id: {
+      type: 'string',
+      description: `The id of this node. Must be unique among all nodes.`,
+      isRequired: true,
+    },
+    type: {
+      type: 'Enum',
+    },
+    image: {
+      type: 'all-of',
+      description: `image to process`,
+      contains: [{
+        type: 'ImageField',
+      }],
+    },
+    detect_resolution: {
+      type: 'number',
+      description: `pixel resolution for edge detection`,
+    },
+    image_resolution: {
+      type: 'number',
+      description: `pixel resolution for output image`,
+    },
+    coarse: {
+      type: 'boolean',
+      description: `whether to use coarse mode`,
+    },
+  },
+} as const;

invokeai/frontend/web/src/services/api/schemas/$MidasDepthImageProcessorInvocation.ts

@@ -0,0 +1,31 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $MidasDepthImageProcessorInvocation = {
+  description: `Applies Midas depth processing to image`,
+  properties: {
+    id: {
+      type: 'string',
+      description: `The id of this node. Must be unique among all nodes.`,
+      isRequired: true,
+    },
+    type: {
+      type: 'Enum',
+    },
+    image: {
+      type: 'all-of',
+      description: `image to process`,
+      contains: [{
+        type: 'ImageField',
+      }],
+    },
+    a_mult: {
+      type: 'number',
+      description: `Midas parameter a = amult * PI`,
+    },
+    bg_th: {
+      type: 'number',
+      description: `Midas parameter bg_th`,
+    },
+  },
+} as const;

invokeai/frontend/web/src/services/api/schemas/$MlsdImageProcessorInvocation.ts

@@ -0,0 +1,39 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $MlsdImageProcessorInvocation = {
+  description: `Applies MLSD processing to image`,
+  properties: {
+    id: {
+      type: 'string',
+      description: `The id of this node. Must be unique among all nodes.`,
+      isRequired: true,
+    },
+    type: {
+      type: 'Enum',
+    },
+    image: {
+      type: 'all-of',
+      description: `image to process`,
+      contains: [{
+        type: 'ImageField',
+      }],
+    },
+    detect_resolution: {
+      type: 'number',
+      description: `pixel resolution for edge detection`,
+    },
+    image_resolution: {
+      type: 'number',
+      description: `pixel resolution for output image`,
+    },
+    thr_v: {
+      type: 'number',
+      description: `MLSD parameter thr_v`,
+    },
+    thr_d: {
+      type: 'number',
+      description: `MLSD parameter thr_d`,
+    },
+  },
+} as const;

invokeai/frontend/web/src/services/api/schemas/$NormalbaeImageProcessorInvocation.ts

@@ -0,0 +1,31 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $NormalbaeImageProcessorInvocation = {
+  description: `Applies NormalBae processing to image`,
+  properties: {
+    id: {
+      type: 'string',
+      description: `The id of this node. Must be unique among all nodes.`,
+      isRequired: true,
+    },
+    type: {
+      type: 'Enum',
+    },
+    image: {
+      type: 'all-of',
+      description: `image to process`,
+      contains: [{
+        type: 'ImageField',
+      }],
+    },
+    detect_resolution: {
+      type: 'number',
+      description: `pixel resolution for edge detection`,
+    },
+    image_resolution: {
+      type: 'number',
+      description: `pixel resolution for output image`,
+    },
+  },
+} as const;

invokeai/frontend/web/src/services/api/schemas/$OpenposeImageProcessorInvocation.ts

@@ -0,0 +1,35 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $OpenposeImageProcessorInvocation = {
+  description: `Applies Openpose processing to image`,
+  properties: {
+    id: {
+      type: 'string',
+      description: `The id of this node. Must be unique among all nodes.`,
+      isRequired: true,
+    },
+    type: {
+      type: 'Enum',
+    },
+    image: {
+      type: 'all-of',
+      description: `image to process`,
+      contains: [{
+        type: 'ImageField',
+      }],
+    },
+    hand_and_face: {
+      type: 'boolean',
+      description: `whether to use hands and face mode`,
+    },
+    detect_resolution: {
+      type: 'number',
+      description: `pixel resolution for edge detection`,
+    },
+    image_resolution: {
+      type: 'number',
+      description: `pixel resolution for output image`,
+    },
+  },
+} as const;

invokeai/frontend/web/src/services/api/schemas/$PidiImageProcessorInvocation.ts

@@ -0,0 +1,39 @@
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $PidiImageProcessorInvocation = {
+  description: `Applies PIDI processing to image`,
+  properties: {
+    id: {
+      type: 'string',
+      description: `The id of this node. Must be unique among all nodes.`,
+      isRequired: true,
+    },
+    type: {
+      type: 'Enum',
+    },
+    image: {
+      type: 'all-of',
+      description: `image to process`,
+      contains: [{
+        type: 'ImageField',
+      }],
+    },
+    detect_resolution: {
+      type: 'number',
+      description: `pixel resolution for edge detection`,
+    },
+    image_resolution: {
+      type: 'number',
+      description: `pixel resolution for output image`,
+    },
+    safe: {
+      type: 'boolean',
+      description: `whether to use safe mode`,
+    },
+    scribble: {
+      type: 'boolean',
+      description: `whether to use scribble mode`,
+    },
+  },
+} as const;