/**
 * Minimal `EventEmitter` interface that is molded against the Node.js
 * `EventEmitter` interface.
 */
declare class EventEmitter<
  EventTypes extends EventEmitter.ValidEventTypes = string | symbol,
  Context extends any = any
> {
  static prefixed: string | boolean;

  /**
   * Return an array listing the events for which the emitter has registered
   * listeners.
   */
  eventNames(): Array<EventEmitter.EventNames<EventTypes>>;

  /**
   * Return the listeners registered for a given event.
   */
  listeners<T extends EventEmitter.EventNames<EventTypes>>(
    event: T
  ): Array<EventEmitter.EventListener<EventTypes, T>>;

  /**
   * Return the number of listeners listening to a given event.
   */
  listenerCount(event: EventEmitter.EventNames<EventTypes>): number;

  /**
   * Calls each of the listeners registered for a given event.
   */
  emit<T extends EventEmitter.EventNames<EventTypes>>(
    event: T,
    ...args: EventEmitter.EventArgs<EventTypes, T>
  ): boolean;

  /**
   * Add a listener for a given event.
   */
  on<T extends EventEmitter.EventNames<EventTypes>>(
    event: T,
    fn: EventEmitter.EventListener<EventTypes, T>,
    context?: Context
  ): this;
  addListener<T extends EventEmitter.EventNames<EventTypes>>(
    event: T,
    fn: EventEmitter.EventListener<EventTypes, T>,
    context?: Context
  ): this;

  /**
   * Add a one-time listener for a given event.
   */
  once<T extends EventEmitter.EventNames<EventTypes>>(
    event: T,
    fn: EventEmitter.EventListener<EventTypes, T>,
    context?: Context
  ): this;

  /**
   * Remove the listeners of a given event.
   */
  removeListener<T extends EventEmitter.EventNames<EventTypes>>(
    event: T,
    fn?: EventEmitter.EventListener<EventTypes, T>,
    context?: Context,
    once?: boolean
  ): this;
  off<T extends EventEmitter.EventNames<EventTypes>>(
    event: T,
    fn?: EventEmitter.EventListener<EventTypes, T>,
    context?: Context,
    once?: boolean
  ): this;

  /**
   * Remove all listeners, or those of the specified event.
   */
  removeAllListeners(event?: EventEmitter.EventNames<EventTypes>): this;
}

declare namespace EventEmitter {
  export interface ListenerFn<Args extends any[] = any[]> {
    (...args: Args): void;
  }

  export interface EventEmitterStatic {
    new <
      EventTypes extends ValidEventTypes = string | symbol,
      Context = any
    >(): EventEmitter<EventTypes, Context>;
  }

  /**
   * `object` should be in either of the following forms:
   * ```
   * interface EventTypes {
   *   'event-with-parameters': any[]
   *   'event-with-example-handler': (...args: any[]) => void
   * }
   * ```
   */
  export type ValidEventTypes = string | symbol | object;

  export type EventNames<T extends ValidEventTypes> = T extends string | symbol
    ? T
    : keyof T;

  export type ArgumentMap<T extends object> = {
    [K in keyof T]: T[K] extends (...args: any[]) => void
      ? Parameters<T[K]>
      : T[K] extends any[]
      ? T[K]
      : any[];
  };

  export type EventListener<
    T extends ValidEventTypes,
    K extends EventNames<T>
  > = T extends string | symbol
    ? (...args: any[]) => void
    : (
        ...args: ArgumentMap<Exclude<T, string | symbol>>[Extract<K, keyof T>]
      ) => void;

  export type EventArgs<
    T extends ValidEventTypes,
    K extends EventNames<T>
  > = Parameters<EventListener<T, K>>;

  export const EventEmitter: EventEmitterStatic;
}

declare namespace ComfyUiWsTypes {
    namespace Messages {
        interface Executed {
            node: string;
            display_node: string;
            output: Record<string, any>;
            prompt_id: string;
            timestamp: number;
        }
        interface ExecutionInterrupted {
            prompt_id: string;
            node_id: string;
            node_type: string;
            executed: string[];
        }
        interface Executing {
            node: string;
            display_node: string;
            prompt_id: string;
            timestamp: number;
        }
        interface Progress {
            value: number;
            max: number;
            prompt_id: string;
            node: string;
        }
        interface ProgressState {
            prompt_id: string;
            nodes: Record<string, {
                value: number;
                max: number;
                state: string;
                node_id: string;
                display_node_id: string;
                parent_node_id: string | null;
                real_node_id: string;
            }>;
        }
        interface Status {
            status: {
                exec_info: {
                    queue_remaining: number;
                };
            };
        }
        interface ExecutionStart {
            prompt_id: string;
            timestamp: number;
        }
        interface ExecutionError {
            prompt_id: string;
            node_id: string;
            node_type: string;
            executed: string[];
            exception_message: string;
            exception_type: string;
            traceback: string;
            current_inputs: any;
            current_outputs: any[];
        }
        interface ExecutionCached {
            nodes: string[];
            prompt_id: string;
            timestamp: number;
        }
        interface ExecutionSuccess {
            prompt_id: string;
            timestamp: number;
        }
    }
    namespace BinaryMessages {
        interface ProgressText {
            nodeId: string;
            text: string;
        }
        interface BinaryPreviewWithMetadata {
            blob: Blob;
            nodeId: string;
            displayNodeId: string;
            parentNodeId: string;
            realNodeId: string;
            promptId: string;
        }
    }
}
type ComfyUIClientEvents = {
    status: [ComfyUiWsTypes.Messages.Status["status"] | null];
    progress: [ComfyUiWsTypes.Messages.Progress];
    progress_state: [ComfyUiWsTypes.Messages.ProgressState];
    executing: [ComfyUiWsTypes.Messages.Executing];
    executed: [ComfyUiWsTypes.Messages.Executed];
    execution_interrupted: [ComfyUiWsTypes.Messages.ExecutionInterrupted];
    execution_start: [ComfyUiWsTypes.Messages.ExecutionStart];
    execution_error: [ComfyUiWsTypes.Messages.ExecutionError];
    execution_cached: [ComfyUiWsTypes.Messages.ExecutionCached];
    execution_success: [ComfyUiWsTypes.Messages.ExecutionSuccess];
    connected: [];
    reconnected: [];
    reconnecting: [];
    /**
     * binary image preview
     *
     * from binary data sent by the server
     */
    b_preview: [Blob];
    b_preview_with_metadata: [
        ComfyUiWsTypes.BinaryMessages.BinaryPreviewWithMetadata
    ];
    /**
     * progress text
     *
     * from binary data sent by the server
     */
    progress_text: [ComfyUiWsTypes.BinaryMessages.ProgressText];
    /**
     * load image data from websocket
     */
    image_data: [
        {
            image: ArrayBuffer;
            mime: string;
        }
    ];
    /**
     * get all messages
     */
    message: [MessageEvent<any>];
    /**
     * close client
     */
    close: [];
    connection_error: [{
        type: string;
        message: string;
    }];
    /**
     * unhandled event message
     */
    unhandled: [{
        type: string;
        data: any;
    }];
};

type FnHook<N extends keyof Client = keyof Client, Fn extends Client[N] = Client[N]> = Fn extends (...args: any) => any ? {
    type: "function";
    name: N;
    fn: (original: Fn, ...args: Parameters<Fn>) => ReturnType<Fn>;
} : never;
type PluginHook<N extends keyof Client = keyof Client, Fn extends Client[N] = Client[N]> = FnHook<N, Fn>;
declare class Plugin {
    private hooks;
    install(instance: Client): void;
    protected addHook<N extends keyof Client = keyof Client, Fn extends Client[N] = Client[N]>(hook: PluginHook<N, Fn>): void;
}

declare namespace ComfyUIClientResponseTypes {
    export interface SystemStatsRoot {
        system: System;
        devices: Device[];
    }
    export interface System {
        os: string;
        python_version: string;
        embedded_python: boolean;
        comfyui_version: string;
        pytorch_version: string;
        required_frontend_version?: string;
        argv: string[];
        ram_total: number;
        ram_free: number;
        cloud_version?: string;
        comfyui_frontend_version?: string;
        workflow_templates_version?: string;
    }
    export interface Device {
        name: string;
        type: string;
        index: number;
        vram_total: number;
        vram_free: number;
        torch_vram_total: number;
        torch_vram_free: number;
    }
    interface NodeConfig {
        input: NodeInputs;
        output: Array<string[] | string>;
        output_is_list: boolean[];
        output_name: string[];
        name: string;
        display_name: string;
        description: string;
        category: string;
        output_node: boolean;
    }
    type NodeInputs = {
        required?: Record<string, NodeSlot>;
        optional?: Record<string, NodeSlot>;
        hidden?: Record<string, NodeSlot>;
    };
    type NodeSlot = [string, NodeOptions] | [string];
    type NodeOptions = Record<string, any>;
    export interface ObjectInfo {
        [k: string]: NodeConfig;
    }
    export type ApiError = {
        type: string;
        message: string;
        details: string;
        extra_info?: {
            input_name?: string;
        };
    };
    export type NodeError = {
        errors: ApiError[];
        class_type: string;
        dependent_outputs: any[];
    };
    export type QueuePromptSuccess = {
        prompt_id: string;
        exec_info?: {
            queue_remaining?: number;
        };
    };
    export type QueuePromptError = {
        error: string | NodeError;
        node_errors: Record<string, NodeError>;
    };
    export type QueuePrompt = QueuePromptSuccess | QueuePromptError;
    export {};
}

type WorkflowOutput<D = unknown> = {
    images: ({
        type: "buff";
        data: ArrayBuffer;
        mime: string;
    } | {
        type: "url";
        data: string;
    })[];
    prompt_id: string;
    /**
     * Allows for a custom resolver to be provided.
     *
     * The custom resolver can parse non-image data into the `data` property, supporting generics.
     *
     * Related: https://github.com/StableCanvas/comfyui-client/issues/10
     */
    data?: D;
};
interface IWorkflow {
    prompt: Record<string, WorkflowPromptNode>;
    workflow?: {
        nodes: [];
        links: [];
        groups: [];
        config: {};
        extra: {};
        version: 0.4;
    };
}
type WorkflowPromptNode = {
    class_type: string;
    inputs: Record<string, any>;
};

/**
 * The Client class provides a high-level interface for interacting with the ComfyUI API.
 *
 * @extends WsClient
 *
 * @example
 * ```typescript
 * const client = new Client({
 *  api_host: "YOUR_API_HOST",
 *  clientId: "YOUR_CLIENT_ID",
 * });
 *
 * const extensions = await client.getEmbeddings();
 * console.log(extensions);
 * ```
 */
declare class Client extends WsClient {
    private _plugins;
    constructor(config: Omit<IComfyApiConfig, "fetch" | "WebSocket"> & {
        fetch?: any;
        WebSocket?: any;
    });
    /**
     * Use a plugin by calling its install method on this instance.
     *
     * @param {Plugin} plugin - The plugin to install.
     */
    use(plugin: Plugin): void;
    /**
     * Gets a list of extension urls
     * @returns An array of script urls to import
     */
    getExtensions(): Promise<string[]>;
    /**
     * Gets a list of embedding names
     * @returns An array of script urls to import
     */
    getEmbeddings(): Promise<string[]>;
    /**
     * Loads node object definitions for the graph
     * @returns {Promise<ComfyUIClientResponseTypes.ObjectInfo>} The object info for the graph
     */
    getNodeDefs(): Promise<ComfyUIClientResponseTypes.ObjectInfo>;
    /**
     *
     * @param {number} queue_index The index at which to queue the prompt, passing -1 will insert the prompt at the front of the queue
     * @param {Object} options
     * @param {Object} options.prompt The prompt to queue
     * @param {Object} options.workflow This png info to be added to resulting image
     * @returns {Promise<ComfyUIClientResponseTypes.QueuePrompt>} The response from the server
     */
    queuePrompt(queue_index: number, { prompt, workflow }: {
        prompt: any;
        workflow: any;
    }): Promise<ComfyUIClientResponseTypes.QueuePrompt>;
    /**
     * Loads a list of items (queue or history)
     * @param {"queue" | "history"} type The type of items to load, queue or history
     * @returns The items of the specified type grouped by their status
     */
    getItems(type: "history"): ReturnType<Client["getHistory"]>;
    getItems(type: "queue"): ReturnType<Client["getQueue"]>;
    /**
     * Gets the current state of the queue
     * @returns The currently running and queued items
     */
    getQueue(): Promise<{
        Running: Array<PromptBody>;
        Pending: Array<PromptBody>;
    }>;
    /**
     * Gets the prompt execution history
     * @returns Prompt history including node outputs
     */
    getHistory(max_items?: number, options?: {
        offset?: number;
    }): Promise<{
        History: Array<PromptQueueItem>;
    }>;
    /**
     * Gets system & device stats
     * @returns {ComfyUIClientResponseTypes.SystemStatsRoot} System stats such as python version, OS, per device info
     */
    getSystemStats(): Promise<ComfyUIClientResponseTypes.SystemStatsRoot>;
    /**
     * Sends a POST request to the API
     * @param {string} type The endpoint to post to
     * @param {any} body Optional POST data
     */
    private postApi;
    /**
     * Deletes an item from the specified list
     * @param {"queue" | "history"} type The type of item to delete, queue or history
     * @param {any} id The id of the item to delete
     */
    deleteItem(type: "queue" | "history", id: any): Promise<void>;
    /**
     * Clears the specified list
     * @param {"queue" | "history"} type The type of list to clear, queue or history
     */
    clearItems(type: "queue" | "history"): Promise<void>;
    /**
     * Interrupts the execution of the running prompt. If runningPromptId is provided,
     * it is included in the payload as a helpful hint to the backend.
     * @param {string | null} [runningPromptId] Optional Running Prompt ID to interrupt
     */
    interrupt(runningPromptId?: string | null): Promise<void>;
    /**
     * Free up memory by unloading models and freeing memory
     */
    free(params?: {
        unload_models?: boolean;
        free_memory?: boolean;
    }): Promise<void>;
    /**
     * Gets user configuration data and where data should be stored
     * @returns { Promise<{ storage: "server" | "browser", users?: Promise<string, unknown>, migrated?: boolean }> }
     */
    getUserConfig(): Promise<any>;
    /**
     * Creates a new user
     * @param { string } username
     * @returns The fetch response
     */
    createUser(username: string): Promise<Response>;
    /**
     * Gets all setting values for the current user
     * @returns { Promise<string, unknown> } A dictionary of id -> value
     */
    getSettings(): Promise<Record<string, unknown>>;
    /**
     * Gets a setting for the current user
     * @param { string } id The id of the setting to fetch
     * @returns { Promise<unknown> } The setting value
     */
    getSetting(id: string): Promise<unknown>;
    /**
     * Stores a dictionary of settings for the current user
     * @param { Record<string, unknown> } settings Dictionary of setting id -> value to save
     * @returns { Promise<void> }
     */
    storeSettings(settings: Record<string, unknown>): Promise<Response>;
    /**
     * Stores a setting for the current user
     * @param { string } id The id of the setting to update
     * @param { unknown } value The value of the setting
     * @returns { Promise<void> }
     */
    storeSetting(id: string, value: unknown): Promise<Response>;
    /**
     * Gets a user data file for the current user
     * @param { string } file The name of the userdata file to load
     * @param { RequestInit } [options]
     * @returns { Promise<unknown> } The fetch response object
     */
    getUserData(file: string, options?: RequestInit): Promise<Response>;
    /**
     * Stores a user data file for the current user
     * @param { string } file The name of the userdata file to save
     * @param { any } data The data to save to the file
     * @param { RequestInit & { stringify?: boolean, throwOnError?: boolean } } [options]
     * @returns { Promise<void> }
     */
    storeUserData(file: string, data: any, options?: RequestInit & {
        stringify?: boolean;
        throwOnError?: boolean;
    }): Promise<void>;
    /**
     * Gets a list of model folder keys (eg ['checkpoints', 'loras', ...])
     * @returns The list of model folder keys
     */
    getModelFolders(): Promise<ModelFolderInfo[]>;
    /**
     * Gets a list of models in the specified folder
     * @param {string} folder The folder to list models from, such as 'checkpoints'
     * @returns The list of model filenames within the specified folder
     */
    getModels(folder: string): Promise<ModelFile[]>;
    /**
     * Gets the metadata for a model
     * @param {string} folder The folder containing the model
     * @param {string} model The model to get metadata for
     * @returns The metadata for the model
     */
    viewMetadata(folder: string, model: string): Promise<any>;
    getLogs(): Promise<string>;
    getRawLogs(): Promise<LogsRawResponse>;
    /**
     * Retrieves the list of samplers from the node definitions.
     *
     * @return {Promise<string[]>} A promise that resolves to an array of strings representing the sampler names.
     */
    getSamplers(): Promise<string[]>;
    /**
     * Retrieves the list of schedulers from the node definitions.
     *
     * @return {Promise<string[]>} A promise that resolves to an array of strings representing the scheduler names.
     */
    getSchedulers(): Promise<string[]>;
    /**
     * Retrieves the list of model names from the node definitions.
     *
     * @return {Promise<string[]>} A promise that resolves to an array of strings representing the model names.
     */
    getSDModels(): Promise<string[]>;
    /**
     * Retrieves the list of model names from the node definitions.
     *
     * @return {Promise<string[]>} A promise that resolves to an array of strings representing the model names.
     */
    getCNetModels(): Promise<string[]>;
    /**
     * Retrieves the list of model names from the node definitions for the UpscaleModelLoader node.
     *
     * @return {Promise<string[]>} A promise that resolves to an array of strings representing the model names.
     */
    getUpscaleModels(): Promise<string[]>;
    /**
     * Retrieves the list of hypernetwork names from the node definitions.
     *
     * @return {Promise<string[]>} A promise that resolves to an array of strings representing the hypernetwork names.
     */
    getHyperNetworks(): Promise<string[]>;
    /**
     * Retrieves the list of LoRAs from the node definitions.
     *
     * @return {Promise<string[]>} A promise that resolves to an array of strings representing the LoRAs.
     */
    getLoRAs(): Promise<string[]>;
    /**
     * Retrieves the list of VAE names from the node definitions.
     *
     * @return {Promise<string[]>} A promise that resolves to an array of strings representing the VAE names.
     */
    getVAEs(): Promise<string[]>;
    /**
     * Retrieves the status of a prompt based on the provided prompt ID.
     *
     * @param {string} prompt_id - The ID of the prompt to check status for.
     * @return {Object} Object containing the running, pending, and done status of the prompt.
     */
    getPromptStatus(prompt_id: string): Promise<{
        running: boolean;
        pending: boolean;
        done: boolean;
    }>;
    /**
     * Retrieves the outputs of a prompt with the given ID from the history.
     *
     * @param {string} prompt_id - The ID of the prompt to retrieve the outputs for.
     * @return {Promise<Record<string, any>>} A promise that resolves to the outputs of the prompt.
     * @throws {Error} If the prompt with the given ID is not found in the history or if it failed with a non-"success" status.
     */
    getPromptOutputs(prompt_id: string): Promise<Record<string, any>>;
    /**
     * Retrieves the result of a prompt with the given ID, resolved using the provided resolver.
     *
     * @param {string} prompt_id - The ID of the prompt to retrieve the result for.
     * @param {WorkflowOutputResolver<T>} resolver - The resolver to use when resolving the prompt result.
     * @return {Promise<WorkflowOutput<T>>} A promise that resolves to the result of the prompt.
     */
    getPromptResult<T>(prompt_id: string, resolver: WorkflowOutputResolver<T>): Promise<WorkflowOutput<T>>;
    getPromptResult(prompt_id: string): Promise<WorkflowOutput>;
    /**
     * Asynchronously waits for the prompt with the provided ID to be done.
     *
     * @param {string} prompt_id - The ID of the prompt to wait for.
     * @param {number} [polling_ms=1000] - The number of milliseconds to wait between checks.
     * @param {number} [timeout_ms=5 * 60 * 1000] - The maximum number of milliseconds to wait. defaults to 5 minutes. must be greater than 1000ms.
     * @return {void}
     */
    waitForPrompt(prompt_id: string, polling_ms?: number, timeout_ms?: number): Promise<void>;
    /**
     * Asynchronously waits for the prompt with the provided ID to be done,
     * using a WebSocket connection to receive updates.
     *
     * @param {string} prompt_id - The ID of the prompt to wait for.
     * @param {WorkflowOutputResolver<T>} resolver - A function to resolve the output of the prompt.
     * @param {number} [timeout_ms=5 * 60 * 1000] - The maximum number of milliseconds to wait. defaults to 5 minutes. must be greater than 1000ms.
     * @return {Promise<WorkflowOutput<T>>} A promise that resolves with the output of the prompt.
     */
    waitForPromptWebSocket<T>(prompt_id: string, resolver: WorkflowOutputResolver<T>, timeout_ms?: number): Promise<WorkflowOutput<T>>;
    /**
     * Asynchronously enqueues a prompt with optional workflow and random seed.
     *
     * @param {Record<string, unknown>} prompt - The prompt to enqueue.
     * @param {Object} [options] - The options for enqueueing the prompt.
     * @param {Record<string, unknown>} [options.workflow] - The workflow for the prompt.
     * @return {Promise<ComfyUIClientResponseTypes.QueuePromptSuccess>} A promise that resolves with the enqueued prompt response.
     * @throws {Error} If there is an error in the response.
     */
    _enqueue_prompt(prompt: Record<string, unknown>, options?: {
        workflow?: Record<string, unknown>;
    }): Promise<ComfyUIClientResponseTypes.QueuePromptSuccess>;
    /**
     * Asynchronously runs a prompt with the provided options.
     *
     * This function does not use WebSocket, but uses polling to get the result
     * So if your workflow contains custom ws events, this function will not be able to get these events
     *
     * @param {Record<string, unknown>} prompt - The prompt to run.
     * @param {Object} options - The options for running the prompt.
     * @param {Record<string, unknown>} options.workflow - The workflow for the prompt, It will be added to the png info of the generated image.
     * @param {number} [options.polling_ms=1000] - The number of milliseconds to polling query prompt result.
     * @param {number} [options.timeout_ms=5 * 60 * 1000] - The number of milliseconds to wait for the prompt result. must be greater than 1000.
     * @return {Promise<WorkflowOutput>} A promise that resolves with the prompt result.
     *
     * @deprecated Use `enqueue_polling` instead
     */
    runPrompt(prompt: Record<string, unknown>, options?: {
        workflow?: Record<string, unknown>;
        polling_ms?: number;
        timeout_ms?: number;
    }): Promise<WorkflowOutput<WorkflowOutput>>;
    /**
     * Asynchronously enqueues a prompt and waits for the corresponding prompt websocket.
     *
     * This function does not use WebSocket, but uses polling to get the result
     * So if your workflow contains custom ws events, this function will not be able to get these events
     *
     * @param {Record<string, unknown>} prompt - The prompt to enqueue.
     * @param {EnqueueOptions<T>} [options] - The options for enqueueing the prompt.
     * @return {Promise<WorkflowOutput<T>>} A promise that resolves with the prompt result.
     */
    enqueue_polling<T>(prompt: Record<string, unknown>, options?: EnqueueOptions<T>): Promise<WorkflowOutput<T>>;
    enqueue_polling(prompt: Record<string, unknown>, options?: EnqueueOptions): Promise<WorkflowOutput>;
    /**
     * Enqueues a prompt and waits for the corresponding prompt websocket.
     *
     * @param {Record<string, unknown>} prompt - The prompt to enqueue.
     * @param {EnqueueOptions<T>} [options] - The options for enqueueing the prompt.
     * @return {Promise<WorkflowOutput>} A promise that resolves with the prompt result.
     */
    enqueue<T>(prompt: Record<string, unknown>, options?: EnqueueOptions<T>): Promise<WorkflowOutput<T>>;
    enqueue(prompt: Record<string, unknown>, options?: EnqueueOptions): Promise<WorkflowOutput>;
    /**
     * Listens for progress updates for a specific task.
     *
     * @param {EnqueueOptions["progress"]} fn - The progress callback function.
     * @param {string} task_id - The ID of the task to listen for progress updates.
     * @return {Function} A function that can be used to remove the progress listener.
     */
    on_progress(fn: EnqueueOptions["progress"], task_id: string): () => void;
}

type WorkflowOutputResolver<T = unknown> = (acc: WorkflowOutput<T>, output: Record<string, unknown>, ctx: {
    client: Client;
    prompt_id: string;
    node_id: string;
}) => WorkflowOutput<T>;
type EnqueueOptions<T = unknown> = {
    /**
     * this data for PNG info
     */
    workflow?: Record<string, unknown>;
    disable_random_seed?: boolean;
    progress?: (p: ComfyUiWsTypes.Messages.Progress) => void;
    on_error?: (err: Error) => void;
    resolver?: WorkflowOutputResolver<T>;
    polling_ms?: number;
    timeout_ms?: number;
};
interface IComfyApiConfig {
    /**
     * The host address of the API server, defaults to '127.0.0.1:8188'.
     * @type {string} [api_host="127.0.0.1:8188"]
     */
    api_host?: string;
    /**
     * The base path for the API endpoints, default is an empty string.
     * @type {string} [api_base=""]
     */
    api_base?: string;
    /**
     * The client identification string, default is an empty string.
     * @type {string} [clientId=""]
     */
    clientId?: string;
    /**
     * The name of the session, used for identifying the session instance, default is an empty string.
     * @type {string} [sessionName=""]
     */
    sessionName?: string;
    /**
     * The username for authentication, default is 'sc-comfy-ui-client'.
     * @type {string} [user="""]
     */
    user?: string;
    /**
     * Whether to use SSL for the connections, defaults to false.
     * @type {boolean} [ssl=false]
     */
    ssl?: boolean;
    /**
     * These settings are for compatibility with Node.js environments.
     * @type {typeof WebSocket} [WebSocket] - The WebSocket class to use.
     */
    WebSocket?: typeof WebSocket;
    /**
     * These settings are for compatibility with Node.js environments.
     * @type {typeof fetch} [fetch] - The fetch function to use.
     */
    fetch?: typeof fetch;
}
type PromptMessage = [
    event_name: string,
    body: {
        prompt_id: number;
        timestamp: number;
    }
];
type PromptBody = [
    index: number,
    id: string,
    workflow: object,
    payload: {
        client_id: string;
        create_time: number;
        extra_pnginfo: {
            workflow: Record<string, unknown>;
            [key: string]: any;
        };
    },
    outputs: string[]
];
interface PromptQueueItem {
    prompt: PromptBody;
    outputs: Record<string, any>;
    status?: {
        status_str: "success" | "error";
        completed: boolean;
        messages: PromptMessage[];
    };
    meta?: Record<string, any>;
}
interface PromptQueueHistory {
    [prompt_id: string]: PromptQueueItem;
}
interface ModelFolderInfo {
    name: string;
    folders: string[];
}
interface ModelFile {
    name: string;
    pathIndex: number;
}
interface TerminalSize {
    cols: number;
    row: number;
}
interface LogEntry {
    t: string;
    m: string;
}
interface LogsRawResponse {
    size: TerminalSize;
    entries: LogEntry[];
}

/**
 * A client for interacting with the ComfyUI API server using WebSockets.
 *
 * NOTE: CORS policy: Request header field comfy-user is not allowed by Access-Control-Allow-Headers in preflight response. Please config.use empty string in browser.
 *
 * @example
 * ```typescript
 * const client = new WsClient({
 *  api_host: "YOUR_API_HOST"
 * });
 *
 * // Connect to the server
 * client.connect();
 *
 * // Listen for status updates
 * client.on("status", (status) => {
 *   console.log("Status:", status);
 * });
 *
 * // when done, close the client
 * client.close();
 */
declare class WsClient {
    static DEFAULT_API_HOST: string;
    static DEFAULT_API_BASE: string;
    static DEFAULT_USER: string;
    static IS_BROWSER: boolean;
    static readBinaryData(buf: ArrayBuffer): readonly [{
        readonly type: "progress_text";
        readonly data: {
            readonly nodeId: string;
            readonly text: string;
        };
    }] | readonly [{
        readonly type: "b_preview";
        readonly data: Blob;
    }] | readonly [{
        readonly type: "b_preview_with_metadata";
        readonly data: {
            readonly blob: Blob;
            readonly nodeId: any;
            readonly displayNodeId: any;
            readonly parentNodeId: any;
            readonly realNodeId: any;
            readonly promptId: any;
        };
    }, {
        readonly type: "b_preview";
        readonly data: Blob;
    }];
    api_host: string;
    api_base: string;
    clientId?: string;
    socket?: WebSocket | null;
    WebSocket: typeof WebSocket;
    ssl: boolean;
    user: string;
    fetch: typeof fetch;
    events: EventEmitter<ComfyUIClientEvents & Record<string & {}, any>>;
    protected socket_callbacks: Record<string, any>;
    get registered(): ((string & {}) | keyof ComfyUIClientEvents)[];
    constructor(config: IComfyApiConfig);
    /**
     * Returns the headers for the API request.
     *
     * @param {RequestInit} [options] - (Optional) Additional options for the request.
     * @return {HeadersInit} The headers for the API request.
     */
    apiHeaders(options?: RequestInit): HeadersInit;
    /**
     * Generates the URL for the API endpoint based on the provided route.
     *
     * @param {string} route - The route for the API endpoint.
     * @return {string} The generated URL for the API endpoint.
     */
    apiURL(route: string): string;
    internalURL(route: string): string;
    /**
     * Generates a URL for viewing a specific file with the given filename, subfolder, and type.
     *
     * @param {string} filename - The name of the file to view.
     * @param {string} subfolder - The subfolder where the file is located.
     * @param {string} type - The type of the file.
     * @return {string} The URL for viewing the file.
     */
    viewURL(filename: string, subfolder: string, type: string): string;
    /**
     * Generates the WebSocket URL based on the current API host and SSL configuration.
     *
     * @return {string} The generated WebSocket URL.
     */
    wsURL(): string;
    /**
     * Fetches API data based on the provided route and options.
     *
     * NOTE: CORS policy: Request header field comfy-user is not allowed by Access-Control-Allow-Headers in preflight response. Please use empty string in browser.
     *
     * @param {string} route - The route for the API request.
     * @param {RequestInit} [options] - (Optional) Additional options for the request.
     * @return {Promise<Response>} A promise that resolves to the API response.
     */
    fetchApi(route: string, options?: RequestInit): Promise<Response>;
    /**
     * Adds an event listener for the specified event type.
     *
     * @param {keyof ComfyUIClientEvents | (string & {})} type - The type of event to listen for.
     * @param {(...args: any) => void} callback - The callback function to be executed when the event is triggered.
     * @param {any} options - (Optional) Additional options for the event listener.
     * @return {() => void} A function that removes the event listener when called.
     */
    addEventListener<T extends EventEmitter.EventNames<ComfyUIClientEvents>>(type: T, callback: EventEmitter.EventListener<ComfyUIClientEvents, T>, options?: any): () => void;
    /**
     * Adds an event listener for the specified event type.
     *
     * @param {keyof ComfyUIClientEvents | (string & {})} type - The type of event to listen for.
     * @param {(...args: any) => void} callback - The callback function to be executed when the event is triggered.
     * @param {any} options - (Optional) Additional options for the event listener.
     * @return {() => void} A function that removes the event listener when called.
     */
    on<T extends EventEmitter.EventNames<ComfyUIClientEvents>>(type: T, callback: EventEmitter.EventListener<ComfyUIClientEvents, T>, options?: any): () => void;
    /**
     * Adds an event listener for the specified event type.
     *
     * @param {keyof ComfyUIClientEvents | (string & {})} type - The type of event to listen for.
     * @param {(...args: any) => void} callback - The callback function to be executed when the event is triggered.
     * @param {any} options - (Optional) Additional options for the event listener.
     * @return {() => void} A function that removes the event listener when called.
     */
    once<T extends EventEmitter.EventNames<ComfyUIClientEvents>>(type: T, callback: EventEmitter.EventListener<ComfyUIClientEvents, T>, options?: any): () => void;
    protected _polling_timer: any;
    protected _polling_interval: number;
    /**
     * Poll status for colab and other things that don't support websockets.
     */
    private startPollingQueue;
    protected addSocketCallback<K extends keyof WebSocketEventMap>(socket: WebSocket, type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): () => void;
    /**
     * Removes all event listeners from the given WebSocket and clears the socket_callbacks object.
     */
    protected removeSocketCallbacks(): void;
    /**
     * Creates and connects a WebSocket for realtime updates
     * @param {boolean} isReconnect If the socket is connection is a reconnect attempt
     */
    private createSocket;
    /**
     * Initializes sockets and realtime updates
     *
     * @deprecated move to client.connect()
     */
    init(): void;
    closed: boolean;
    /**
     * Closes the WebSocket connection and cleans up event listeners
     */
    close(): void;
    /**
     * Connects to the WebSocket server by creating a new socket connection.
     *
     * @param {Object} options - The options for connecting to the server.
     * @param {Object} options.polling - The options for polling.
     * @param {boolean} options.polling.enabled - Whether polling is enabled.
     * @param {number} [options.polling.interval] - The interval for polling.
     * @param {Object} options.websocket - The options for the WebSocket connection.
     * @param {boolean} options.websocket.enabled - Whether the WebSocket connection is enabled.
     * @param {number} [options.timeout_ms] - The timeout for the connection in milliseconds.
     * @return {Promise<boolean>} - A promise that resolves to true if the connection was successful, false otherwise.
     */
    connect({ polling, websocket, timeout_ms, }?: {
        polling?: {
            enabled: boolean;
            interval?: number;
        };
        websocket?: {
            enabled: boolean;
        };
        timeout_ms?: number;
    }): Promise<unknown>;
    /**
     * Disconnects the WebSocket connection and cleans up event listeners.
     */
    disconnect(): void;
    /**
     * Disconnects the WebSocket connection and cleans up event listeners.
     *
     * @return {void} This function does not return anything.
     */
    _disconnectSocket(): void;
    /**
     * Disconnects the polling timer and sets it to null.
     *
     * @return {void}
     */
    _disconnectPolling(): void;
}

declare class Disposable {
    protected _disposed: boolean;
    protected _disposed_cbs: any[];
    dispose(): void;
    _connect(cb: () => void): void;
}

declare class InvokedWorkflow<T = unknown> extends Disposable {
    readonly options: {
        workflow: IWorkflow;
        client: Client;
        resolver?: WorkflowOutputResolver<T>;
        progress?: (p: ComfyUiWsTypes.Messages.Progress) => void;
        on_error?: (e: Error) => void;
    };
    protected _task_id?: string;
    protected _result: WorkflowOutput<T>;
    is_done: boolean;
    enqueued: boolean;
    workflow: IWorkflow;
    client: Client;
    resolver: WorkflowOutputResolver<T>;
    /**
     * 因为 comfyui 的 websocket events 顺序混乱，在 execution_success 立马结束也可能导致事件丢失
     *
     * Because the order of comfyui's websocket events is chaotic, the execution_success event may end immediately, causing events to be lost
     */
    delay_done_ms: number;
    /**
     *  The current task is being executed via WebSocket; this flag is used to determine whether the current `image_data` originates from this task.
     */
    is_current_ws_executing: boolean;
    constructor(options: {
        workflow: IWorkflow;
        client: Client;
        resolver?: WorkflowOutputResolver<T>;
        progress?: (p: ComfyUiWsTypes.Messages.Progress) => void;
        on_error?: (e: Error) => void;
    });
    get is_disposed(): boolean;
    get task_id(): string | undefined;
    protected _enqueue_guard(): void;
    protected _task_id_guard(): string;
    protected _done_guard(): void;
    protected _ws_guard(): void;
    protected is_owner_event(...args: any[]): boolean;
    /**
     * Adds an event listener for the specified event type.
     */
    on<T extends EventEmitter.EventNames<ComfyUIClientEvents>>(type: T, callback: EventEmitter.EventListener<ComfyUIClientEvents, T>, options?: any): () => void;
    /**
     * Adds an once event listener for the specified event type.
     */
    once<T extends EventEmitter.EventNames<ComfyUIClientEvents>>(type: T, callback: EventEmitter.EventListener<ComfyUIClientEvents, T>, options?: any): () => void;
    /**
     * Initiates the workflow by enqueuing the prompt and setting up the task ID.
     *
     * @return {void}
     */
    enqueue(): Promise<void>;
    protected hook_progress(): Promise<void>;
    protected hook_executing(): Promise<void>;
    protected hook_image_data(): Promise<void>;
    protected resolve_to_result(data: ComfyUiWsTypes.Messages.Executed): void;
    /**
     * Retrieves the execution status of the workflow.
     *
     * @return {Promise<status>} A promise that resolves with the execution status of the workflow.
     */
    query(): Promise<{
        running: boolean;
        pending: boolean;
        done: boolean;
    }>;
    /**
     * Interrupts the execution of the workflow if it is currently enqueued.
     * Throws an error if the workflow is not enqueued or if the execution status cannot be interrupted.
     *
     * @return {Promise<void>} A promise that resolves when the interrupt is successful or rejects with an error.
     * @throws {Error} If the workflow is not enqueued or if the execution status cannot be interrupted.
     */
    interrupt(): Promise<void>;
    protected collect_result(): Promise<WorkflowOutput<T>>;
    protected when_interrupted(cb: (data: ComfyUiWsTypes.Messages.ExecutionInterrupted) => any): void;
    protected when_execution_error(cb: (data: ComfyUiWsTypes.Messages.ExecutionError) => any): void;
    /**
     * Listen for the start event of the workflow.
     * @param {Function} cb - The callback function that will be called when the workflow starts.
     * @return {Function} A function that can be used to remove the listener.
     */
    on_start(cb: () => void): void;
    /**
     * Waits for the workflow to complete and returns the result.
     *
     * *This function does not rely on WebSocket Events, so it will lose events output by WebSocket node
     *
     * @param {Object} options - options for waiting
     * @param {number} [options.polling_ms=1000] - polling interval in milliseconds
     * @return {Promise} promise that resolves with the result of the workflow
     */
    wait_polling({ polling_ms }?: {
        polling_ms?: number;
    }): Promise<WorkflowOutput>;
    /**
     * Waits for the workflow to complete and returns the result.
     *
     * @return {Promise<WorkflowOutput>} promise that resolves with the result of the workflow
     */
    wait(): Promise<WorkflowOutput>;
}

declare namespace ComfyUINodeTypes {
    interface NodeTypes {
        KSampler?: KSampler;
        CheckpointLoaderSimple?: CheckpointLoaderSimple;
        CLIPTextEncode?: CLIPTextEncode;
        CLIPSetLastLayer?: CLIPSetLastLayer;
        VAEDecode?: VAEDecode;
        VAEEncode?: VAEEncode;
        VAEEncodeForInpaint?: VAEEncodeForInpaint;
        VAELoader?: VAELoader;
        EmptyLatentImage?: EmptyLatentImage;
        LatentUpscale?: LatentUpscale;
        LatentUpscaleBy?: LatentUpscaleBy;
        LatentFromBatch?: LatentFromBatch;
        RepeatLatentBatch?: RepeatLatentBatch;
        SaveImage?: SaveImage;
        PreviewImage?: PreviewImage;
        LoadImage?: LoadImage;
        LoadImageMask?: LoadImageMask;
        LoadImageOutput?: LoadImageOutput;
        ImageScale?: ImageScale;
        ImageScaleBy?: ImageScaleBy;
        ImageInvert?: ImageInvert;
        ImageBatch?: ImageBatch;
        ImagePadForOutpaint?: ImagePadForOutpaint;
        EmptyImage?: EmptyImage;
        ConditioningAverage?: ConditioningAverage;
        ConditioningCombine?: ConditioningCombine;
        ConditioningConcat?: ConditioningConcat;
        ConditioningSetArea?: ConditioningSetArea;
        ConditioningSetAreaPercentage?: ConditioningSetAreaPercentage;
        ConditioningSetAreaStrength?: ConditioningSetAreaStrength;
        ConditioningSetMask?: ConditioningSetMask;
        KSamplerAdvanced?: KSamplerAdvanced;
        SetLatentNoiseMask?: SetLatentNoiseMask;
        LatentComposite?: LatentComposite;
        LatentBlend?: LatentBlend;
        LatentRotate?: LatentRotate;
        LatentFlip?: LatentFlip;
        LatentCrop?: LatentCrop;
        LoraLoader?: LoraLoader;
        CLIPLoader?: CLIPLoader;
        UNETLoader?: UNETLoader;
        DualCLIPLoader?: DualCLIPLoader;
        CLIPVisionEncode?: CLIPVisionEncode;
        StyleModelApply?: StyleModelApply;
        unCLIPConditioning?: unCLIPConditioning;
        ControlNetApply?: ControlNetApply;
        ControlNetApplyAdvanced?: ControlNetApplyAdvanced;
        ControlNetLoader?: ControlNetLoader;
        DiffControlNetLoader?: DiffControlNetLoader;
        StyleModelLoader?: StyleModelLoader;
        CLIPVisionLoader?: CLIPVisionLoader;
        VAEDecodeTiled?: VAEDecodeTiled;
        VAEEncodeTiled?: VAEEncodeTiled;
        unCLIPCheckpointLoader?: unCLIPCheckpointLoader;
        GLIGENLoader?: GLIGENLoader;
        GLIGENTextBoxApply?: GLIGENTextBoxApply;
        InpaintModelConditioning?: InpaintModelConditioning;
        CheckpointLoader?: CheckpointLoader;
        DiffusersLoader?: DiffusersLoader;
        LoadLatent?: LoadLatent;
        SaveLatent?: SaveLatent;
        ConditioningZeroOut?: ConditioningZeroOut;
        ConditioningSetTimestepRange?: ConditioningSetTimestepRange;
        LoraLoaderModelOnly?: LoraLoaderModelOnly;
        LatentAdd?: LatentAdd;
        LatentSubtract?: LatentSubtract;
        LatentMultiply?: LatentMultiply;
        LatentInterpolate?: LatentInterpolate;
        LatentConcat?: LatentConcat;
        LatentCut?: LatentCut;
        LatentBatch?: LatentBatch;
        LatentBatchSeedBehavior?: LatentBatchSeedBehavior;
        LatentApplyOperation?: LatentApplyOperation;
        LatentApplyOperationCFG?: LatentApplyOperationCFG;
        LatentOperationTonemapReinhard?: LatentOperationTonemapReinhard;
        LatentOperationSharpen?: LatentOperationSharpen;
        HypernetworkLoader?: HypernetworkLoader;
        UpscaleModelLoader?: UpscaleModelLoader;
        ImageUpscaleWithModel?: ImageUpscaleWithModel;
        ImageBlend?: ImageBlend;
        ImageBlur?: ImageBlur;
        ImageQuantize?: ImageQuantize;
        ImageSharpen?: ImageSharpen;
        ImageScaleToTotalPixels?: ImageScaleToTotalPixels;
        LatentCompositeMasked?: LatentCompositeMasked;
        ImageCompositeMasked?: ImageCompositeMasked;
        MaskToImage?: MaskToImage;
        ImageToMask?: ImageToMask;
        ImageColorToMask?: ImageColorToMask;
        SolidMask?: SolidMask;
        InvertMask?: InvertMask;
        CropMask?: CropMask;
        MaskComposite?: MaskComposite;
        FeatherMask?: FeatherMask;
        GrowMask?: GrowMask;
        ThresholdMask?: ThresholdMask;
        MaskPreview?: MaskPreview;
        PorterDuffImageComposite?: PorterDuffImageComposite;
        SplitImageWithAlpha?: SplitImageWithAlpha;
        JoinImageWithAlpha?: JoinImageWithAlpha;
        RebatchLatents?: RebatchLatents;
        RebatchImages?: RebatchImages;
        ModelMergeSimple?: ModelMergeSimple;
        ModelMergeBlocks?: ModelMergeBlocks;
        ModelMergeSubtract?: ModelMergeSubtract;
        ModelMergeAdd?: ModelMergeAdd;
        CheckpointSave?: CheckpointSave;
        CLIPMergeSimple?: CLIPMergeSimple;
        CLIPMergeSubtract?: CLIPMergeSubtract;
        CLIPMergeAdd?: CLIPMergeAdd;
        CLIPSave?: CLIPSave;
        VAESave?: VAESave;
        ModelSave?: ModelSave;
        TomePatchModel?: TomePatchModel;
        CLIPTextEncodeSDXLRefiner?: CLIPTextEncodeSDXLRefiner;
        CLIPTextEncodeSDXL?: CLIPTextEncodeSDXL;
        Canny?: Canny;
        FreeU?: FreeU;
        FreeU_V2?: FreeU_V2;
        SamplerCustom?: SamplerCustom;
        BasicScheduler?: BasicScheduler;
        KarrasScheduler?: KarrasScheduler;
        ExponentialScheduler?: ExponentialScheduler;
        PolyexponentialScheduler?: PolyexponentialScheduler;
        LaplaceScheduler?: LaplaceScheduler;
        VPScheduler?: VPScheduler;
        BetaSamplingScheduler?: BetaSamplingScheduler;
        SDTurboScheduler?: SDTurboScheduler;
        KSamplerSelect?: KSamplerSelect;
        SamplerEulerAncestral?: SamplerEulerAncestral;
        SamplerEulerAncestralCFGPP?: SamplerEulerAncestralCFGPP;
        SamplerLMS?: SamplerLMS;
        SamplerDPMPP_3M_SDE?: SamplerDPMPP_3M_SDE;
        SamplerDPMPP_2M_SDE?: SamplerDPMPP_2M_SDE;
        SamplerDPMPP_SDE?: SamplerDPMPP_SDE;
        SamplerDPMPP_2S_Ancestral?: SamplerDPMPP_2S_Ancestral;
        SamplerDPMAdaptative?: SamplerDPMAdaptative;
        SamplerER_SDE?: SamplerER_SDE;
        SamplerSASolver?: SamplerSASolver;
        SplitSigmas?: SplitSigmas;
        SplitSigmasDenoise?: SplitSigmasDenoise;
        FlipSigmas?: FlipSigmas;
        SetFirstSigma?: SetFirstSigma;
        ExtendIntermediateSigmas?: ExtendIntermediateSigmas;
        SamplingPercentToSigma?: SamplingPercentToSigma;
        CFGGuider?: CFGGuider;
        DualCFGGuider?: DualCFGGuider;
        BasicGuider?: BasicGuider;
        RandomNoise?: RandomNoise;
        DisableNoise?: DisableNoise;
        AddNoise?: AddNoise;
        SamplerCustomAdvanced?: SamplerCustomAdvanced;
        HyperTile?: HyperTile;
        ModelSamplingDiscrete?: ModelSamplingDiscrete;
        ModelSamplingContinuousEDM?: ModelSamplingContinuousEDM;
        ModelSamplingContinuousV?: ModelSamplingContinuousV;
        ModelSamplingStableCascade?: ModelSamplingStableCascade;
        ModelSamplingSD3?: ModelSamplingSD3;
        ModelSamplingAuraFlow?: ModelSamplingAuraFlow;
        ModelSamplingFlux?: ModelSamplingFlux;
        RescaleCFG?: RescaleCFG;
        ModelComputeDtype?: ModelComputeDtype;
        PatchModelAddDownscale?: PatchModelAddDownscale;
        ImageOnlyCheckpointLoader?: ImageOnlyCheckpointLoader;
        SVD_img2vid_Conditioning?: SVD_img2vid_Conditioning;
        VideoLinearCFGGuidance?: VideoLinearCFGGuidance;
        VideoTriangleCFGGuidance?: VideoTriangleCFGGuidance;
        ImageOnlyCheckpointSave?: ImageOnlyCheckpointSave;
        ConditioningSetAreaPercentageVideo?: ConditioningSetAreaPercentageVideo;
        TrainLoraNode?: TrainLoraNode;
        SaveLoRANode?: SaveLoRANode;
        LoraModelLoader?: LoraModelLoader;
        LoadImageSetFromFolderNode?: LoadImageSetFromFolderNode;
        LoadImageTextSetFromFolderNode?: LoadImageTextSetFromFolderNode;
        LossGraphNode?: LossGraphNode;
        SelfAttentionGuidance?: SelfAttentionGuidance;
        PerpNeg?: PerpNeg;
        PerpNegGuider?: PerpNegGuider;
        StableZero123_Conditioning?: StableZero123_Conditioning;
        StableZero123_Conditioning_Batched?: StableZero123_Conditioning_Batched;
        SV3D_Conditioning?: SV3D_Conditioning;
        SD_4XUpscale_Conditioning?: SD_4XUpscale_Conditioning;
        PhotoMakerLoader?: PhotoMakerLoader;
        PhotoMakerEncode?: PhotoMakerEncode;
        CLIPTextEncodePixArtAlpha?: CLIPTextEncodePixArtAlpha;
        CLIPTextEncodeControlnet?: CLIPTextEncodeControlnet;
        T5TokenizerOptions?: T5TokenizerOptions;
        Morphology?: Morphology;
        ImageRGBToYUV?: ImageRGBToYUV;
        ImageYUVToRGB?: ImageYUVToRGB;
        StableCascade_EmptyLatentImage?: StableCascade_EmptyLatentImage;
        StableCascade_StageB_Conditioning?: StableCascade_StageB_Conditioning;
        StableCascade_StageC_VAEEncode?: StableCascade_StageC_VAEEncode;
        StableCascade_SuperResolutionControlnet?: StableCascade_SuperResolutionControlnet;
        DifferentialDiffusion?: DifferentialDiffusion;
        InstructPixToPixConditioning?: InstructPixToPixConditioning;
        ModelMergeSD1?: ModelMergeSD1;
        ModelMergeSD2?: ModelMergeSD2;
        ModelMergeSDXL?: ModelMergeSDXL;
        ModelMergeSD3_2B?: ModelMergeSD3_2B;
        ModelMergeAuraflow?: ModelMergeAuraflow;
        ModelMergeFlux1?: ModelMergeFlux1;
        ModelMergeSD35_Large?: ModelMergeSD35_Large;
        ModelMergeMochiPreview?: ModelMergeMochiPreview;
        ModelMergeLTXV?: ModelMergeLTXV;
        ModelMergeCosmos7B?: ModelMergeCosmos7B;
        ModelMergeCosmos14B?: ModelMergeCosmos14B;
        ModelMergeWAN2_1?: ModelMergeWAN2_1;
        ModelMergeCosmosPredict2_2B?: ModelMergeCosmosPredict2_2B;
        ModelMergeCosmosPredict2_14B?: ModelMergeCosmosPredict2_14B;
        ModelMergeQwenImage?: ModelMergeQwenImage;
        PerturbedAttentionGuidance?: PerturbedAttentionGuidance;
        AlignYourStepsScheduler?: AlignYourStepsScheduler;
        UNetSelfAttentionMultiply?: UNetSelfAttentionMultiply;
        UNetCrossAttentionMultiply?: UNetCrossAttentionMultiply;
        CLIPAttentionMultiply?: CLIPAttentionMultiply;
        UNetTemporalAttentionMultiply?: UNetTemporalAttentionMultiply;
        SamplerLCMUpscale?: SamplerLCMUpscale;
        SamplerEulerCFGpp?: SamplerEulerCFGpp;
        WebcamCapture?: WebcamCapture;
        EmptyLatentAudio?: EmptyLatentAudio;
        VAEEncodeAudio?: VAEEncodeAudio;
        VAEDecodeAudio?: VAEDecodeAudio;
        SaveAudio?: SaveAudio;
        SaveAudioMP3?: SaveAudioMP3;
        SaveAudioOpus?: SaveAudioOpus;
        LoadAudio?: LoadAudio;
        PreviewAudio?: PreviewAudio;
        ConditioningStableAudio?: ConditioningStableAudio;
        RecordAudio?: RecordAudio;
        TripleCLIPLoader?: TripleCLIPLoader;
        EmptySD3LatentImage?: EmptySD3LatentImage;
        CLIPTextEncodeSD3?: CLIPTextEncodeSD3;
        ControlNetApplySD3?: ControlNetApplySD3;
        SkipLayerGuidanceSD3?: SkipLayerGuidanceSD3;
        GITSScheduler?: GITSScheduler;
        SetUnionControlNetType?: SetUnionControlNetType;
        ControlNetInpaintingAliMamaApply?: ControlNetInpaintingAliMamaApply;
        CLIPTextEncodeHunyuanDiT?: CLIPTextEncodeHunyuanDiT;
        TextEncodeHunyuanVideo_ImageToVideo?: TextEncodeHunyuanVideo_ImageToVideo;
        EmptyHunyuanLatentVideo?: EmptyHunyuanLatentVideo;
        HunyuanImageToVideo?: HunyuanImageToVideo;
        CLIPTextEncodeFlux?: CLIPTextEncodeFlux;
        FluxGuidance?: FluxGuidance;
        FluxDisableGuidance?: FluxDisableGuidance;
        FluxKontextImageScale?: FluxKontextImageScale;
        FluxKontextMultiReferenceLatentMethod?: FluxKontextMultiReferenceLatentMethod;
        LoraSave?: LoraSave;
        TorchCompileModel?: TorchCompileModel;
        EmptyMochiLatentVideo?: EmptyMochiLatentVideo;
        SkipLayerGuidanceDiT?: SkipLayerGuidanceDiT;
        SkipLayerGuidanceDiTSimple?: SkipLayerGuidanceDiTSimple;
        Mahiro?: Mahiro;
        EmptyLTXVLatentVideo?: EmptyLTXVLatentVideo;
        LTXVImgToVideo?: LTXVImgToVideo;
        ModelSamplingLTXV?: ModelSamplingLTXV;
        LTXVConditioning?: LTXVConditioning;
        LTXVScheduler?: LTXVScheduler;
        LTXVAddGuide?: LTXVAddGuide;
        LTXVPreprocess?: LTXVPreprocess;
        LTXVCropGuides?: LTXVCropGuides;
        CreateHookLora?: CreateHookLora;
        CreateHookLoraModelOnly?: CreateHookLoraModelOnly;
        CreateHookModelAsLora?: CreateHookModelAsLora;
        CreateHookModelAsLoraModelOnly?: CreateHookModelAsLoraModelOnly;
        SetHookKeyframes?: SetHookKeyframes;
        CreateHookKeyframe?: CreateHookKeyframe;
        CreateHookKeyframesInterpolated?: CreateHookKeyframesInterpolated;
        CreateHookKeyframesFromFloats?: CreateHookKeyframesFromFloats;
        CombineHooks2?: CombineHooks2;
        CombineHooks4?: CombineHooks4;
        CombineHooks8?: CombineHooks8;
        ConditioningSetProperties?: ConditioningSetProperties;
        ConditioningSetPropertiesAndCombine?: ConditioningSetPropertiesAndCombine;
        PairConditioningSetProperties?: PairConditioningSetProperties;
        PairConditioningSetPropertiesAndCombine?: PairConditioningSetPropertiesAndCombine;
        ConditioningSetDefaultCombine?: ConditioningSetDefaultCombine;
        PairConditioningSetDefaultCombine?: PairConditioningSetDefaultCombine;
        PairConditioningCombine?: PairConditioningCombine;
        SetClipHooks?: SetClipHooks;
        ConditioningTimestepsRange?: ConditioningTimestepsRange;
        Load3D?: Load3D;
        Load3DAnimation?: Load3DAnimation;
        Preview3D?: Preview3D;
        Preview3DAnimation?: Preview3DAnimation;
        EmptyCosmosLatentVideo?: EmptyCosmosLatentVideo;
        CosmosImageToVideoLatent?: CosmosImageToVideoLatent;
        CosmosPredict2ImageToVideoLatent?: CosmosPredict2ImageToVideoLatent;
        SaveWEBM?: SaveWEBM;
        SaveVideo?: SaveVideo;
        CreateVideo?: CreateVideo;
        GetVideoComponents?: GetVideoComponents;
        LoadVideo?: LoadVideo;
        CLIPTextEncodeLumina2?: CLIPTextEncodeLumina2;
        RenormCFG?: RenormCFG;
        WanTrackToVideo?: WanTrackToVideo;
        WanImageToVideo?: WanImageToVideo;
        WanFunControlToVideo?: WanFunControlToVideo;
        Wan22FunControlToVideo?: Wan22FunControlToVideo;
        WanFunInpaintToVideo?: WanFunInpaintToVideo;
        WanFirstLastFrameToVideo?: WanFirstLastFrameToVideo;
        WanVaceToVideo?: WanVaceToVideo;
        TrimVideoLatent?: TrimVideoLatent;
        WanCameraImageToVideo?: WanCameraImageToVideo;
        WanPhantomSubjectToVideo?: WanPhantomSubjectToVideo;
        WanSoundImageToVideo?: WanSoundImageToVideo;
        WanSoundImageToVideoExtend?: WanSoundImageToVideoExtend;
        Wan22ImageToVideoLatent?: Wan22ImageToVideoLatent;
        LotusConditioning?: LotusConditioning;
        EmptyLatentHunyuan3Dv2?: EmptyLatentHunyuan3Dv2;
        Hunyuan3Dv2Conditioning?: Hunyuan3Dv2Conditioning;
        Hunyuan3Dv2ConditioningMultiView?: Hunyuan3Dv2ConditioningMultiView;
        VAEDecodeHunyuan3D?: VAEDecodeHunyuan3D;
        VoxelToMeshBasic?: VoxelToMeshBasic;
        VoxelToMesh?: VoxelToMesh;
        SaveGLB?: SaveGLB;
        PrimitiveString?: PrimitiveString;
        PrimitiveStringMultiline?: PrimitiveStringMultiline;
        PrimitiveInt?: PrimitiveInt;
        PrimitiveFloat?: PrimitiveFloat;
        PrimitiveBoolean?: PrimitiveBoolean;
        CFGZeroStar?: CFGZeroStar;
        CFGNorm?: CFGNorm;
        OptimalStepsScheduler?: OptimalStepsScheduler;
        QuadrupleCLIPLoader?: QuadrupleCLIPLoader;
        CLIPTextEncodeHiDream?: CLIPTextEncodeHiDream;
        FreSca?: FreSca;
        APG?: APG;
        PreviewAny?: PreviewAny;
        TextEncodeAceStepAudio?: TextEncodeAceStepAudio;
        EmptyAceStepLatentAudio?: EmptyAceStepLatentAudio;
        StringConcatenate?: StringConcatenate;
        StringSubstring?: StringSubstring;
        StringLength?: StringLength;
        CaseConverter?: CaseConverter;
        StringTrim?: StringTrim;
        StringReplace?: StringReplace;
        StringContains?: StringContains;
        StringCompare?: StringCompare;
        RegexMatch?: RegexMatch;
        RegexExtract?: RegexExtract;
        RegexReplace?: RegexReplace;
        WanCameraEmbedding?: WanCameraEmbedding;
        ReferenceLatent?: ReferenceLatent;
        TCFG?: TCFG;
        ContextWindowsManual?: ContextWindowsManual;
        WanContextWindowsManual?: WanContextWindowsManual;
        TextEncodeQwenImageEdit?: TextEncodeQwenImageEdit;
        ModelPatchLoader?: ModelPatchLoader;
        QwenImageDiffsynthControlnet?: QwenImageDiffsynthControlnet;
        EasyCache?: EasyCache;
        LazyCache?: LazyCache;
        AudioEncoderLoader?: AudioEncoderLoader;
        AudioEncoderEncode?: AudioEncoderEncode;
        ["Animation Builder (mtb)"]?: Animation_Builder__mtb_;
        ["Audio Sequence (mtb)"]?: Audio_Sequence__mtb_;
        ["Audio Stack (mtb)"]?: Audio_Stack__mtb_;
        ["Audio Cut (mtb)"]?: Audio_Cut__mtb_;
        ["Audio Resample (mtb)"]?: Audio_Resample__mtb_;
        ["Audio Isolate Speaker (mtb)"]?: Audio_Isolate_Speaker__mtb_;
        ["Load Whisper (mtb)"]?: Load_Whisper__mtb_;
        ["Audio To Text (mtb)"]?: Audio_To_Text__mtb_;
        ["Process Whisper Output (mtb)"]?: Process_Whisper_Output__mtb_;
        ["Process Whisper Diarization (mtb)"]?: Process_Whisper_Diarization__mtb_;
        ["Audio Duration (mtb)"]?: Audio_Duration__mtb_;
        ["Batch2d Transform (mtb)"]?: Batch2d_Transform__mtb_;
        ["Batch Float (mtb)"]?: Batch_Float__mtb_;
        ["Batch Float Assemble (mtb)"]?: Batch_Float_Assemble__mtb_;
        ["Batch Float Fill (mtb)"]?: Batch_Float_Fill__mtb_;
        ["Batch Float Fit (mtb)"]?: Batch_Float_Fit__mtb_;
        ["Batch Float Math (mtb)"]?: Batch_Float_Math__mtb_;
        ["Batch Float Normalize (mtb)"]?: Batch_Float_Normalize__mtb_;
        ["Batch From Folder (mtb)"]?: Batch_From_Folder__mtb_;
        ["Batch Make (mtb)"]?: Batch_Make__mtb_;
        ["Batch Merge (mtb)"]?: Batch_Merge__mtb_;
        ["Batch Sequence (mtb)"]?: Batch_Sequence__mtb_;
        ["Batch Sequence Plus (mtb)"]?: Batch_Sequence_Plus__mtb_;
        ["Batch Shake (mtb)"]?: Batch_Shake__mtb_;
        ["Batch Shape (mtb)"]?: Batch_Shape__mtb_;
        ["Batch Time Wrap (mtb)"]?: Batch_Time_Wrap__mtb_;
        ["Plot Batch Float (mtb)"]?: Plot_Batch_Float__mtb_;
        ["Sublist To Image Batch (mtb)"]?: Sublist_To_Image_Batch__mtb_;
        ["Image Batch To Sublist (mtb)"]?: Image_Batch_To_Sublist__mtb_;
        ["Smart Step (mtb)"]?: Smart_Step__mtb_;
        ["Styles Loader (mtb)"]?: Styles_Loader__mtb_;
        ["Interpolate Clip Sequential (mtb)"]?: Interpolate_Clip_Sequential__mtb_;
        ["Interpolate Condition (mtb)"]?: Interpolate_Condition__mtb_;
        ["Bbox From Mask (mtb)"]?: Bbox_From_Mask__mtb_;
        ["Bbox (mtb)"]?: Bbox__mtb_;
        ["Crop (mtb)"]?: Crop__mtb_;
        ["Uncrop (mtb)"]?: Uncrop__mtb_;
        ["Split Bbox (mtb)"]?: Split_Bbox__mtb_;
        ["Upscale Bbox By (mtb)"]?: Upscale_Bbox_By__mtb_;
        ["BBox Force Dimensions (mtb)"]?: BBox_Force_Dimensions__mtb_;
        ["Curve (mtb)"]?: Curve__mtb_;
        ["Curve To Float (mtb)"]?: Curve_To_Float__mtb_;
        ["Debug (mtb)"]?: Debug__mtb_;
        ["Save Tensors (mtb)"]?: Save_Tensors__mtb_;
        ["Deep Bump (mtb)"]?: Deep_Bump__mtb_;
        ["Restore Face (mtb)"]?: Restore_Face__mtb_;
        ["Load Face Enhance Model (mtb)"]?: Load_Face_Enhance_Model__mtb_;
        ["Face Swap (mtb)"]?: Face_Swap__mtb_;
        ["Load Face Swap Model (mtb)"]?: Load_Face_Swap_Model__mtb_;
        ["Load Face Analysis Model (mtb)"]?: Load_Face_Analysis_Model__mtb_;
        ["Filter Z (mtb)"]?: Filter_Z__mtb_;
        ["Unsplash Image (mtb)"]?: Unsplash_Image__mtb_;
        ["Text To Image (mtb)"]?: Text_To_Image__mtb_;
        ["String Replace (mtb)"]?: String_Replace__mtb_;
        ["Fit Number (mtb)"]?: Fit_Number__mtb_;
        ["Get Batch From History (mtb)"]?: Get_Batch_From_History__mtb_;
        ["Any To String (mtb)"]?: Any_To_String__mtb_;
        ["Concat Images (mtb)"]?: Concat_Images__mtb_;
        ["Math Expression (mtb)"]?: Math_Expression__mtb_;
        ["To Device (mtb)"]?: To_Device__mtb_;
        ["Apply Text Template (mtb)"]?: Apply_Text_Template__mtb_;
        ["Match Dimensions (mtb)"]?: Match_Dimensions__mtb_;
        ["Auto Pan Equilateral (mtb)"]?: Auto_Pan_Equilateral__mtb_;
        ["Floats To Float (mtb)"]?: Floats_To_Float__mtb_;
        ["Float To Floats (mtb)"]?: Float_To_Floats__mtb_;
        ["Floats To Ints (mtb)"]?: Floats_To_Ints__mtb_;
        ["Tensor Ops (mtb)"]?: Tensor_Ops__mtb_;
        ["Color Correct (mtb)"]?: Color_Correct__mtb_;
        ["Color Correct GPU (mtb)"]?: Color_Correct_GPU__mtb_;
        ["Image Compare (mtb)"]?: Image_Compare__mtb_;
        ["Image Tile Offset (mtb)"]?: Image_Tile_Offset__mtb_;
        ["Blur (mtb)"]?: Blur__mtb_;
        ["Mask To Image (mtb)"]?: Mask_To_Image__mtb_;
        ["Colored Image (mtb)"]?: Colored_Image__mtb_;
        ["Image Premultiply (mtb)"]?: Image_Premultiply__mtb_;
        ["Image Resize Factor (mtb)"]?: Image_Resize_Factor__mtb_;
        ["Save Image Grid (mtb)"]?: Save_Image_Grid__mtb_;
        ["Load Image From Url (mtb)"]?: Load_Image_From_Url__mtb_;
        ["Sharpen (mtb)"]?: Sharpen__mtb_;
        ["Extract Coordinates From Image (mtb)"]?: Extract_Coordinates_From_Image__mtb_;
        ["Coordinates To String (mtb)"]?: Coordinates_To_String__mtb_;
        ["Stack Images (mtb)"]?: Stack_Images__mtb_;
        ["Pick From Batch (mtb)"]?: Pick_From_Batch__mtb_;
        ["Save Image (mtb)"]?: Save_Image__mtb_;
        ["Save Gif (mtb)"]?: Save_Gif__mtb_;
        ["Export With Ffmpeg (mtb)"]?: Export_With_Ffmpeg__mtb_;
        ["Add To Playlist (mtb)"]?: Add_To_Playlist__mtb_;
        ["Read Playlist (mtb)"]?: Read_Playlist__mtb_;
        ["Latent Lerp (mtb)"]?: Latent_Lerp__mtb_;
        ["Image H264 Compression (mtb)"]?: Image_H264_Compression__mtb_;
        ["Image Remove Background Rembg (mtb)"]?: Image_Remove_Background_Rembg__mtb_;
        ["Model Patch Seamless (mtb)"]?: Model_Patch_Seamless__mtb_;
        ["Vae Decode (mtb)"]?: Vae_Decode__mtb_;
        ["Float To Number (mtb)"]?: Float_To_Number__mtb_;
        ["Int To Bool (mtb)"]?: Int_To_Bool__mtb_;
        ["Int To Number (mtb)"]?: Int_To_Number__mtb_;
        ["Postshot Export (mtb)"]?: Postshot_Export__mtb_;
        ["Postshot Train (mtb)"]?: Postshot_Train__mtb_;
        ["Model Pruner (mtb)"]?: Model_Pruner__mtb_;
        ["Qr Code (mtb)"]?: Qr_Code__mtb_;
        ["Transform Image (mtb)"]?: Transform_Image__mtb_;
        ["Load Image Sequence (mtb)"]?: Load_Image_Sequence__mtb_;
        ["Save Image Sequence (mtb)"]?: Save_Image_Sequence__mtb_;
        ["Load Vit Matte Model (mtb)"]?: Load_Vit_Matte_Model__mtb_;
        ["Generate Trimap (mtb)"]?: Generate_Trimap__mtb_;
        ["Apply Vit Matte (mtb)"]?: Apply_Vit_Matte__mtb_;
        TimestepKeyframe?: TimestepKeyframe;
        ACN_TimestepKeyframeInterpolation?: ACN_TimestepKeyframeInterpolation;
        ACN_TimestepKeyframeFromStrengthList?: ACN_TimestepKeyframeFromStrengthList;
        LatentKeyframe?: LatentKeyframe;
        LatentKeyframeTiming?: LatentKeyframeTiming;
        LatentKeyframeBatchedGroup?: LatentKeyframeBatchedGroup;
        LatentKeyframeGroup?: LatentKeyframeGroup;
        ACN_AdvancedControlNetApply_v2?: ACN_AdvancedControlNetApply_v2;
        ACN_AdvancedControlNetApplySingle_v2?: ACN_AdvancedControlNetApplySingle_v2;
        ACN_ControlNetLoaderAdvanced?: ACN_ControlNetLoaderAdvanced;
        ACN_DiffControlNetLoaderAdvanced?: ACN_DiffControlNetLoaderAdvanced;
        ACN_ScaledSoftControlNetWeights?: ACN_ScaledSoftControlNetWeights;
        ScaledSoftMaskedUniversalWeights?: ScaledSoftMaskedUniversalWeights;
        ACN_SoftControlNetWeightsSD15?: ACN_SoftControlNetWeightsSD15;
        ACN_CustomControlNetWeightsSD15?: ACN_CustomControlNetWeightsSD15;
        ACN_CustomControlNetWeightsFlux?: ACN_CustomControlNetWeightsFlux;
        ACN_SoftT2IAdapterWeights?: ACN_SoftT2IAdapterWeights;
        ACN_CustomT2IAdapterWeights?: ACN_CustomT2IAdapterWeights;
        ACN_DefaultUniversalWeights?: ACN_DefaultUniversalWeights;
        ACN_ExtrasMiddleMult?: ACN_ExtrasMiddleMult;
        ACN_SparseCtrlRGBPreprocessor?: ACN_SparseCtrlRGBPreprocessor;
        ACN_SparseCtrlLoaderAdvanced?: ACN_SparseCtrlLoaderAdvanced;
        ACN_SparseCtrlMergedLoaderAdvanced?: ACN_SparseCtrlMergedLoaderAdvanced;
        ACN_SparseCtrlIndexMethodNode?: ACN_SparseCtrlIndexMethodNode;
        ACN_SparseCtrlSpreadMethodNode?: ACN_SparseCtrlSpreadMethodNode;
        ACN_SparseCtrlWeightExtras?: ACN_SparseCtrlWeightExtras;
        ["ACN_ControlNet++LoaderSingle"]?: ACN_ControlNet__LoaderSingle;
        ["ACN_ControlNet++LoaderAdvanced"]?: ACN_ControlNet__LoaderAdvanced;
        ["ACN_ControlNet++InputNode"]?: ACN_ControlNet__InputNode;
        ACN_CtrLoRALoader?: ACN_CtrLoRALoader;
        ACN_ReferencePreprocessor?: ACN_ReferencePreprocessor;
        ACN_ReferenceControlNet?: ACN_ReferenceControlNet;
        ACN_ReferenceControlNetFinetune?: ACN_ReferenceControlNetFinetune;
        LoadImagesFromDirectory?: LoadImagesFromDirectory;
        ScaledSoftControlNetWeights?: ScaledSoftControlNetWeights;
        SoftControlNetWeights?: SoftControlNetWeights;
        CustomControlNetWeights?: CustomControlNetWeights;
        SoftT2IAdapterWeights?: SoftT2IAdapterWeights;
        CustomT2IAdapterWeights?: CustomT2IAdapterWeights;
        ACN_AdvancedControlNetApply?: ACN_AdvancedControlNetApply;
        ACN_AdvancedControlNetApplySingle?: ACN_AdvancedControlNetApplySingle;
        ControlNetLoaderAdvanced?: ControlNetLoaderAdvanced;
        DiffControlNetLoaderAdvanced?: DiffControlNetLoaderAdvanced;
        ADE_AnimateDiffLoRALoader?: ADE_AnimateDiffLoRALoader;
        ADE_AnimateDiffSamplingSettings?: ADE_AnimateDiffSamplingSettings;
        ADE_AnimateDiffKeyframe?: ADE_AnimateDiffKeyframe;
        ADE_MultivalDynamic?: ADE_MultivalDynamic;
        ADE_MultivalDynamicFloatInput?: ADE_MultivalDynamicFloatInput;
        ADE_MultivalDynamicFloats?: ADE_MultivalDynamicFloats;
        ADE_MultivalScaledMask?: ADE_MultivalScaledMask;
        ADE_MultivalConvertToMask?: ADE_MultivalConvertToMask;
        ADE_StandardStaticContextOptions?: ADE_StandardStaticContextOptions;
        ADE_StandardUniformContextOptions?: ADE_StandardUniformContextOptions;
        ADE_LoopedUniformContextOptions?: ADE_LoopedUniformContextOptions;
        ADE_ViewsOnlyContextOptions?: ADE_ViewsOnlyContextOptions;
        ADE_BatchedContextOptions?: ADE_BatchedContextOptions;
        ADE_AnimateDiffUniformContextOptions?: ADE_AnimateDiffUniformContextOptions;
        ADE_VisualizeContextOptionsK?: ADE_VisualizeContextOptionsK;
        ADE_VisualizeContextOptionsKAdv?: ADE_VisualizeContextOptionsKAdv;
        ADE_VisualizeContextOptionsSCustom?: ADE_VisualizeContextOptionsSCustom;
        ADE_StandardStaticViewOptions?: ADE_StandardStaticViewOptions;
        ADE_StandardUniformViewOptions?: ADE_StandardUniformViewOptions;
        ADE_LoopedUniformViewOptions?: ADE_LoopedUniformViewOptions;
        ADE_ContextExtras_Set?: ADE_ContextExtras_Set;
        ADE_ContextExtras_ContextRef?: ADE_ContextExtras_ContextRef;
        ADE_ContextExtras_ContextRef_ModeFirst?: ADE_ContextExtras_ContextRef_ModeFirst;
        ADE_ContextExtras_ContextRef_ModeSliding?: ADE_ContextExtras_ContextRef_ModeSliding;
        ADE_ContextExtras_ContextRef_ModeIndexes?: ADE_ContextExtras_ContextRef_ModeIndexes;
        ADE_ContextExtras_ContextRef_TuneAttn?: ADE_ContextExtras_ContextRef_TuneAttn;
        ADE_ContextExtras_ContextRef_TuneAttnAdain?: ADE_ContextExtras_ContextRef_TuneAttnAdain;
        ADE_ContextExtras_ContextRef_Keyframe?: ADE_ContextExtras_ContextRef_Keyframe;
        ADE_ContextExtras_ContextRef_KeyframeInterpolation?: ADE_ContextExtras_ContextRef_KeyframeInterpolation;
        ADE_ContextExtras_ContextRef_KeyframeFromList?: ADE_ContextExtras_ContextRef_KeyframeFromList;
        ADE_ContextExtras_NaiveReuse?: ADE_ContextExtras_NaiveReuse;
        ADE_ContextExtras_NaiveReuse_Keyframe?: ADE_ContextExtras_NaiveReuse_Keyframe;
        ADE_ContextExtras_NaiveReuse_KeyframeInterpolation?: ADE_ContextExtras_NaiveReuse_KeyframeInterpolation;
        ADE_ContextExtras_NaiveReuse_KeyframeFromList?: ADE_ContextExtras_NaiveReuse_KeyframeFromList;
        ADE_IterationOptsDefault?: ADE_IterationOptsDefault;
        ADE_IterationOptsFreeInit?: ADE_IterationOptsFreeInit;
        ADE_RegisterLoraHook?: ADE_RegisterLoraHook;
        ADE_RegisterLoraHookModelOnly?: ADE_RegisterLoraHookModelOnly;
        ADE_RegisterModelAsLoraHook?: ADE_RegisterModelAsLoraHook;
        ADE_RegisterModelAsLoraHookModelOnly?: ADE_RegisterModelAsLoraHookModelOnly;
        ADE_CombineLoraHooks?: ADE_CombineLoraHooks;
        ADE_CombineLoraHooksFour?: ADE_CombineLoraHooksFour;
        ADE_CombineLoraHooksEight?: ADE_CombineLoraHooksEight;
        ADE_SetLoraHookKeyframe?: ADE_SetLoraHookKeyframe;
        ADE_AttachLoraHookToCLIP?: ADE_AttachLoraHookToCLIP;
        ADE_LoraHookKeyframe?: ADE_LoraHookKeyframe;
        ADE_LoraHookKeyframeInterpolation?: ADE_LoraHookKeyframeInterpolation;
        ADE_LoraHookKeyframeFromStrengthList?: ADE_LoraHookKeyframeFromStrengthList;
        ADE_AttachLoraHookToConditioning?: ADE_AttachLoraHookToConditioning;
        ADE_PairedConditioningSetMask?: ADE_PairedConditioningSetMask;
        ADE_ConditioningSetMask?: ADE_ConditioningSetMask;
        ADE_PairedConditioningSetMaskAndCombine?: ADE_PairedConditioningSetMaskAndCombine;
        ADE_ConditioningSetMaskAndCombine?: ADE_ConditioningSetMaskAndCombine;
        ADE_PairedConditioningSetUnmaskedAndCombine?: ADE_PairedConditioningSetUnmaskedAndCombine;
        ADE_ConditioningSetUnmaskedAndCombine?: ADE_ConditioningSetUnmaskedAndCombine;
        ADE_PairedConditioningCombine?: ADE_PairedConditioningCombine;
        ADE_ConditioningCombine?: ADE_ConditioningCombine;
        ADE_TimestepsConditioning?: ADE_TimestepsConditioning;
        ADE_NoiseLayerAdd?: ADE_NoiseLayerAdd;
        ADE_NoiseLayerAddWeighted?: ADE_NoiseLayerAddWeighted;
        ADE_NoiseLayerNormalizedSum?: ADE_NoiseLayerNormalizedSum;
        ADE_NoiseLayerReplace?: ADE_NoiseLayerReplace;
        ADE_AnimateDiffSettings?: ADE_AnimateDiffSettings;
        ADE_AdjustPESweetspotStretch?: ADE_AdjustPESweetspotStretch;
        ADE_AdjustPEFullStretch?: ADE_AdjustPEFullStretch;
        ADE_AdjustPEManual?: ADE_AdjustPEManual;
        ADE_AdjustWeightAllAdd?: ADE_AdjustWeightAllAdd;
        ADE_AdjustWeightAllMult?: ADE_AdjustWeightAllMult;
        ADE_AdjustWeightIndivAdd?: ADE_AdjustWeightIndivAdd;
        ADE_AdjustWeightIndivMult?: ADE_AdjustWeightIndivMult;
        ADE_AdjustWeightIndivAttnAdd?: ADE_AdjustWeightIndivAttnAdd;
        ADE_AdjustWeightIndivAttnMult?: ADE_AdjustWeightIndivAttnMult;
        ADE_CustomCFGSimple?: ADE_CustomCFGSimple;
        ADE_CustomCFG?: ADE_CustomCFG;
        ADE_CustomCFGKeyframeSimple?: ADE_CustomCFGKeyframeSimple;
        ADE_CustomCFGKeyframe?: ADE_CustomCFGKeyframe;
        ADE_CustomCFGKeyframeInterpolation?: ADE_CustomCFGKeyframeInterpolation;
        ADE_CustomCFGKeyframeFromList?: ADE_CustomCFGKeyframeFromList;
        ADE_CFGExtrasPAGSimple?: ADE_CFGExtrasPAGSimple;
        ADE_CFGExtrasPAG?: ADE_CFGExtrasPAG;
        ADE_CFGExtrasRescaleCFGSimple?: ADE_CFGExtrasRescaleCFGSimple;
        ADE_CFGExtrasRescaleCFG?: ADE_CFGExtrasRescaleCFG;
        ADE_SigmaSchedule?: ADE_SigmaSchedule;
        ADE_RawSigmaSchedule?: ADE_RawSigmaSchedule;
        ADE_SigmaScheduleWeightedAverage?: ADE_SigmaScheduleWeightedAverage;
        ADE_SigmaScheduleWeightedAverageInterp?: ADE_SigmaScheduleWeightedAverageInterp;
        ADE_SigmaScheduleSplitAndCombine?: ADE_SigmaScheduleSplitAndCombine;
        ADE_SigmaScheduleToSigmas?: ADE_SigmaScheduleToSigmas;
        ADE_NoisedImageInjection?: ADE_NoisedImageInjection;
        ADE_NoisedImageInjectOptions?: ADE_NoisedImageInjectOptions;
        ADE_AncestralOptions?: ADE_AncestralOptions;
        ADE_PromptScheduling?: ADE_PromptScheduling;
        ADE_PromptSchedulingLatents?: ADE_PromptSchedulingLatents;
        ADE_ValueScheduling?: ADE_ValueScheduling;
        ADE_ValueSchedulingLatents?: ADE_ValueSchedulingLatents;
        ADE_ValuesReplace?: ADE_ValuesReplace;
        ADE_FloatToFloats?: ADE_FloatToFloats;
        ADE_ADBlockCombo?: ADE_ADBlockCombo;
        ADE_ADBlockIndiv?: ADE_ADBlockIndiv;
        ADE_PerBlockHighLevel?: ADE_PerBlockHighLevel;
        ADE_PerBlock_SD15_MidLevel?: ADE_PerBlock_SD15_MidLevel;
        ADE_PerBlock_SD15_LowLevel?: ADE_PerBlock_SD15_LowLevel;
        ADE_PerBlock_SD15_FromFloats?: ADE_PerBlock_SD15_FromFloats;
        ADE_PerBlock_SDXL_MidLevel?: ADE_PerBlock_SDXL_MidLevel;
        ADE_PerBlock_SDXL_LowLevel?: ADE_PerBlock_SDXL_LowLevel;
        ADE_PerBlock_SDXL_FromFloats?: ADE_PerBlock_SDXL_FromFloats;
        ADE_AnimateDiffUnload?: ADE_AnimateDiffUnload;
        ADE_EmptyLatentImageLarge?: ADE_EmptyLatentImageLarge;
        CheckpointLoaderSimpleWithNoiseSelect?: CheckpointLoaderSimpleWithNoiseSelect;
        ADE_PerturbedAttentionGuidanceMultival?: ADE_PerturbedAttentionGuidanceMultival;
        ADE_RescaleCFGMultival?: ADE_RescaleCFGMultival;
        ADE_AnimateDiffLoaderGen1?: ADE_AnimateDiffLoaderGen1;
        ADE_UseEvolvedSampling?: ADE_UseEvolvedSampling;
        ADE_ApplyAnimateDiffModelSimple?: ADE_ApplyAnimateDiffModelSimple;
        ADE_ApplyAnimateDiffModel?: ADE_ApplyAnimateDiffModel;
        ADE_LoadAnimateDiffModel?: ADE_LoadAnimateDiffModel;
        ADE_ApplyAnimateLCMI2VModel?: ADE_ApplyAnimateLCMI2VModel;
        ADE_LoadAnimateLCMI2VModel?: ADE_LoadAnimateLCMI2VModel;
        ADE_UpscaleAndVAEEncode?: ADE_UpscaleAndVAEEncode;
        ADE_InjectI2VIntoAnimateDiffModel?: ADE_InjectI2VIntoAnimateDiffModel;
        ADE_ApplyAnimateDiffModelWithCameraCtrl?: ADE_ApplyAnimateDiffModelWithCameraCtrl;
        ADE_LoadAnimateDiffModelWithCameraCtrl?: ADE_LoadAnimateDiffModelWithCameraCtrl;
        ADE_CameraCtrlAnimateDiffKeyframe?: ADE_CameraCtrlAnimateDiffKeyframe;
        ADE_LoadCameraPoses?: ADE_LoadCameraPoses;
        ADE_LoadCameraPosesFromPath?: ADE_LoadCameraPosesFromPath;
        ADE_CameraPoseBasic?: ADE_CameraPoseBasic;
        ADE_CameraPoseCombo?: ADE_CameraPoseCombo;
        ADE_CameraPoseAdvanced?: ADE_CameraPoseAdvanced;
        ADE_CameraManualPoseAppend?: ADE_CameraManualPoseAppend;
        ADE_ReplaceCameraParameters?: ADE_ReplaceCameraParameters;
        ADE_ReplaceOriginalPoseAspectRatio?: ADE_ReplaceOriginalPoseAspectRatio;
        ADE_ApplyAnimateDiffModelWithPIA?: ADE_ApplyAnimateDiffModelWithPIA;
        ADE_InputPIA_Multival?: ADE_InputPIA_Multival;
        ADE_InputPIA_PaperPresets?: ADE_InputPIA_PaperPresets;
        ADE_PIA_AnimateDiffKeyframe?: ADE_PIA_AnimateDiffKeyframe;
        ADE_InjectPIAIntoAnimateDiffModel?: ADE_InjectPIAIntoAnimateDiffModel;
        ADE_AnimateDiffLoaderWithContext?: ADE_AnimateDiffLoaderWithContext;
        AnimateDiffLoaderV1?: AnimateDiffLoaderV1;
        ADE_AnimateDiffLoaderV1Advanced?: ADE_AnimateDiffLoaderV1Advanced;
        ADE_AnimateDiffCombine?: ADE_AnimateDiffCombine;
        ADE_AnimateDiffModelSettings_Release?: ADE_AnimateDiffModelSettings_Release;
        ADE_AnimateDiffModelSettingsSimple?: ADE_AnimateDiffModelSettingsSimple;
        ADE_AnimateDiffModelSettings?: ADE_AnimateDiffModelSettings;
        ADE_AnimateDiffModelSettingsAdvancedAttnStrengths?: ADE_AnimateDiffModelSettingsAdvancedAttnStrengths;
        AutoCropFaces?: AutoCropFaces;
        CLIPSeg?: CLIPSeg;
        CombineSegMasks?: CombineSegMasks;
        LoadDepthPro?: LoadDepthPro;
        RunDepthPro?: RunDepthPro;
        MZ_Flux1PartialLoad_Patch?: MZ_Flux1PartialLoad_Patch;
        MZ_Flux1CheckpointLoaderNF4_cpuDynOffload?: MZ_Flux1CheckpointLoaderNF4_cpuDynOffload;
        MZ_Flux1CheckpointLoader_cpuDynOffload?: MZ_Flux1CheckpointLoader_cpuDynOffload;
        MZ_Flux1UnetLoader_cpuDynOffload?: MZ_Flux1UnetLoader_cpuDynOffload;
        UnetLoaderGGUF?: UnetLoaderGGUF;
        CLIPLoaderGGUF?: CLIPLoaderGGUF;
        DualCLIPLoaderGGUF?: DualCLIPLoaderGGUF;
        TripleCLIPLoaderGGUF?: TripleCLIPLoaderGGUF;
        QuadrupleCLIPLoaderGGUF?: QuadrupleCLIPLoaderGGUF;
        UnetLoaderGGUFAdvanced?: UnetLoaderGGUFAdvanced;
        InpaintCropImproved?: InpaintCropImproved;
        InpaintStitchImproved?: InpaintStitchImproved;
        InpaintCrop?: InpaintCrop;
        InpaintStitch?: InpaintStitch;
        InpaintExtendOutpaint?: InpaintExtendOutpaint;
        InpaintResize?: InpaintResize;
        LoadLotusModel?: LoadLotusModel;
        LotusSampler?: LotusSampler;
        MarigoldModelLoader?: MarigoldModelLoader;
        MarigoldDepthEstimation_v2?: MarigoldDepthEstimation_v2;
        MarigoldDepthEstimation_v2_video?: MarigoldDepthEstimation_v2_video;
        MarigoldDepthEstimation?: MarigoldDepthEstimation;
        MarigoldDepthEstimationVideo?: MarigoldDepthEstimationVideo;
        ColorizeDepthmap?: ColorizeDepthmap;
        SaveImageOpenEXR?: SaveImageOpenEXR;
        RemapDepth?: RemapDepth;
        NunchakuFluxDiTLoader?: NunchakuFluxDiTLoader;
        NunchakuQwenImageDiTLoader?: NunchakuQwenImageDiTLoader;
        NunchakuFluxLoraLoader?: NunchakuFluxLoraLoader;
        NunchakuFluxLoraStack?: NunchakuFluxLoraStack;
        NunchakuTextEncoderLoader?: NunchakuTextEncoderLoader;
        NunchakuTextEncoderLoaderV2?: NunchakuTextEncoderLoaderV2;
        NunchakuDepthPreprocessor?: NunchakuDepthPreprocessor;
        NunchakuPulidApply?: NunchakuPulidApply;
        NunchakuPulidLoader?: NunchakuPulidLoader;
        NunchakuPuLIDLoaderV2?: NunchakuPuLIDLoaderV2;
        NunchakuFluxPuLIDApplyV2?: NunchakuFluxPuLIDApplyV2;
        NunchakuFluxIPAdapterApply?: NunchakuFluxIPAdapterApply;
        NunchakuIPAdapterLoader?: NunchakuIPAdapterLoader;
        NunchakuModelMerger?: NunchakuModelMerger;
        NunchakuWheelInstaller?: NunchakuWheelInstaller;
        ["Robust Video Matting"]?: Robust_Video_Matting;
        ["BRIAAI Matting"]?: BRIAAI_Matting;
        Yoloworld_ModelLoader_Zho?: Yoloworld_ModelLoader_Zho;
        ESAM_ModelLoader_Zho?: ESAM_ModelLoader_Zho;
        Yoloworld_ESAM_Zho?: Yoloworld_ESAM_Zho;
        Yoloworld_ESAM_DetectorProvider_Zho?: Yoloworld_ESAM_DetectorProvider_Zho;
        AnimeFace_SemSegPreprocessor?: AnimeFace_SemSegPreprocessor;
        AnyLineArtPreprocessor_aux?: AnyLineArtPreprocessor_aux;
        BinaryPreprocessor?: BinaryPreprocessor;
        CannyEdgePreprocessor?: CannyEdgePreprocessor;
        ColorPreprocessor?: ColorPreprocessor;
        DensePosePreprocessor?: DensePosePreprocessor;
        DepthAnythingPreprocessor?: DepthAnythingPreprocessor;
        Zoe_DepthAnythingPreprocessor?: Zoe_DepthAnythingPreprocessor;
        DepthAnythingV2Preprocessor?: DepthAnythingV2Preprocessor;
        DiffusionEdge_Preprocessor?: DiffusionEdge_Preprocessor;
        ["DSINE-NormalMapPreprocessor"]?: DSINE_NormalMapPreprocessor;
        DWPreprocessor?: DWPreprocessor;
        AnimalPosePreprocessor?: AnimalPosePreprocessor;
        HEDPreprocessor?: HEDPreprocessor;
        FakeScribblePreprocessor?: FakeScribblePreprocessor;
        InpaintPreprocessor?: InpaintPreprocessor;
        ["LeReS-DepthMapPreprocessor"]?: LeReS_DepthMapPreprocessor;
        LineArtPreprocessor?: LineArtPreprocessor;
        AnimeLineArtPreprocessor?: AnimeLineArtPreprocessor;
        LineartStandardPreprocessor?: LineartStandardPreprocessor;
        Manga2Anime_LineArt_Preprocessor?: Manga2Anime_LineArt_Preprocessor;
        ["MediaPipe-FaceMeshPreprocessor"]?: MediaPipe_FaceMeshPreprocessor;
        ["MeshGraphormer-DepthMapPreprocessor"]?: MeshGraphormer_DepthMapPreprocessor;
        ["MeshGraphormer+ImpactDetector-DepthMapPreprocessor"]?: MeshGraphormer_ImpactDetector_DepthMapPreprocessor;
        ["Metric3D-DepthMapPreprocessor"]?: Metric3D_DepthMapPreprocessor;
        ["Metric3D-NormalMapPreprocessor"]?: Metric3D_NormalMapPreprocessor;
        ["MiDaS-NormalMapPreprocessor"]?: MiDaS_NormalMapPreprocessor;
        ["MiDaS-DepthMapPreprocessor"]?: MiDaS_DepthMapPreprocessor;
        ["M-LSDPreprocessor"]?: M_LSDPreprocessor;
        ["BAE-NormalMapPreprocessor"]?: BAE_NormalMapPreprocessor;
        ["OneFormer-COCO-SemSegPreprocessor"]?: OneFormer_COCO_SemSegPreprocessor;
        ["OneFormer-ADE20K-SemSegPreprocessor"]?: OneFormer_ADE20K_SemSegPreprocessor;
        OpenposePreprocessor?: OpenposePreprocessor;
        PiDiNetPreprocessor?: PiDiNetPreprocessor;
        SavePoseKpsAsJsonFile?: SavePoseKpsAsJsonFile;
        FacialPartColoringFromPoseKps?: FacialPartColoringFromPoseKps;
        UpperBodyTrackingFromPoseKps?: UpperBodyTrackingFromPoseKps;
        RenderPeopleKps?: RenderPeopleKps;
        RenderAnimalKps?: RenderAnimalKps;
        PyraCannyPreprocessor?: PyraCannyPreprocessor;
        ImageLuminanceDetector?: ImageLuminanceDetector;
        ImageIntensityDetector?: ImageIntensityDetector;
        ScribblePreprocessor?: ScribblePreprocessor;
        Scribble_XDoG_Preprocessor?: Scribble_XDoG_Preprocessor;
        Scribble_PiDiNet_Preprocessor?: Scribble_PiDiNet_Preprocessor;
        SAMPreprocessor?: SAMPreprocessor;
        ShufflePreprocessor?: ShufflePreprocessor;
        TEEDPreprocessor?: TEEDPreprocessor;
        TilePreprocessor?: TilePreprocessor;
        TTPlanet_TileGF_Preprocessor?: TTPlanet_TileGF_Preprocessor;
        TTPlanet_TileSimple_Preprocessor?: TTPlanet_TileSimple_Preprocessor;
        ["UniFormer-SemSegPreprocessor"]?: UniFormer_SemSegPreprocessor;
        SemSegPreprocessor?: SemSegPreprocessor;
        Unimatch_OptFlowPreprocessor?: Unimatch_OptFlowPreprocessor;
        MaskOptFlow?: MaskOptFlow;
        ["Zoe-DepthMapPreprocessor"]?: Zoe_DepthMapPreprocessor;
        AIO_Preprocessor?: AIO_Preprocessor;
        ControlNetPreprocessorSelector?: ControlNetPreprocessorSelector;
        PixelPerfectResolution?: PixelPerfectResolution;
        ImageGenResolutionFromImage?: ImageGenResolutionFromImage;
        ImageGenResolutionFromLatent?: ImageGenResolutionFromLatent;
        HintImageEnchance?: HintImageEnchance;
        ExecuteAllControlNetPreprocessors?: ExecuteAllControlNetPreprocessors;
        ControlNetAuxSimpleAddText?: ControlNetAuxSimpleAddText;
        ["CLIPTextEncodeSDXL+"]?: CLIPTextEncodeSDXL_;
        ["ConditioningCombineMultiple+"]?: ConditioningCombineMultiple_;
        ["SD3NegativeConditioning+"]?: SD3NegativeConditioning_;
        ["FluxAttentionSeeker+"]?: FluxAttentionSeeker_;
        ["SD3AttentionSeekerLG+"]?: SD3AttentionSeekerLG_;
        ["SD3AttentionSeekerT5+"]?: SD3AttentionSeekerT5_;
        ["FluxBlocksBuster+"]?: FluxBlocksBuster_;
        ["ImageEnhanceDifference+"]?: ImageEnhanceDifference_;
        ["ImageBatchMultiple+"]?: ImageBatchMultiple_;
        ["ImageExpandBatch+"]?: ImageExpandBatch_;
        ["ImageFromBatch+"]?: ImageFromBatch_;
        ["ImageListToBatch+"]?: ImageListToBatch_;
        ["ImageBatchToList+"]?: ImageBatchToList_;
        ["ImageCompositeFromMaskBatch+"]?: ImageCompositeFromMaskBatch_;
        ["ImageComposite+"]?: ImageComposite_;
        ["ImageCrop+"]?: ImageCrop_;
        ["ImageFlip+"]?: ImageFlip_;
        ["ImageRandomTransform+"]?: ImageRandomTransform_;
        ["ImageRemoveAlpha+"]?: ImageRemoveAlpha_;
        ["ImageRemoveBackground+"]?: ImageRemoveBackground_;
        ["ImageResize+"]?: ImageResize_;
        ["ImageSeamCarving+"]?: ImageSeamCarving_;
        ["ImageTile+"]?: ImageTile_;
        ["ImageUntile+"]?: ImageUntile_;
        ["RemBGSession+"]?: RemBGSession_;
        ["TransparentBGSession+"]?: TransparentBGSession_;
        ["ImageApplyLUT+"]?: ImageApplyLUT_;
        ["ImageCASharpening+"]?: ImageCASharpening_;
        ["ImageDesaturate+"]?: ImageDesaturate_;
        ["PixelOEPixelize+"]?: PixelOEPixelize_;
        ["ImagePosterize+"]?: ImagePosterize_;
        ["ImageColorMatch+"]?: ImageColorMatch_;
        ["ImageColorMatchAdobe+"]?: ImageColorMatchAdobe_;
        ["ImageHistogramMatch+"]?: ImageHistogramMatch_;
        ["ImageSmartSharpen+"]?: ImageSmartSharpen_;
        ["GetImageSize+"]?: GetImageSize_;
        ["ImageToDevice+"]?: ImageToDevice_;
        ["ImagePreviewFromLatent+"]?: ImagePreviewFromLatent_;
        ["NoiseFromImage+"]?: NoiseFromImage_;
        ["MaskBlur+"]?: MaskBlur_;
        ["MaskBoundingBox+"]?: MaskBoundingBox_;
        ["MaskFix+"]?: MaskFix_;
        ["MaskFlip+"]?: MaskFlip_;
        ["MaskFromColor+"]?: MaskFromColor_;
        ["MaskFromList+"]?: MaskFromList_;
        ["MaskFromRGBCMYBW+"]?: MaskFromRGBCMYBW_;
        ["MaskFromSegmentation+"]?: MaskFromSegmentation_;
        ["MaskPreview+"]?: MaskPreview_;
        ["MaskSmooth+"]?: MaskSmooth_;
        ["TransitionMask+"]?: TransitionMask_;
        ["MaskBatch+"]?: MaskBatch_;
        ["MaskExpandBatch+"]?: MaskExpandBatch_;
        ["MaskFromBatch+"]?: MaskFromBatch_;
        ["KSamplerVariationsStochastic+"]?: KSamplerVariationsStochastic_;
        ["KSamplerVariationsWithNoise+"]?: KSamplerVariationsWithNoise_;
        ["InjectLatentNoise+"]?: InjectLatentNoise_;
        ["FluxSamplerParams+"]?: FluxSamplerParams_;
        ["GuidanceTimestepping+"]?: GuidanceTimestepping_;
        ["PlotParameters+"]?: PlotParameters_;
        ["TextEncodeForSamplerParams+"]?: TextEncodeForSamplerParams_;
        ["SamplerSelectHelper+"]?: SamplerSelectHelper_;
        ["SchedulerSelectHelper+"]?: SchedulerSelectHelper_;
        ["LorasForFluxParams+"]?: LorasForFluxParams_;
        ["ModelSamplingSD3Advanced+"]?: ModelSamplingSD3Advanced_;
        ["ApplyCLIPSeg+"]?: ApplyCLIPSeg_;
        ["LoadCLIPSegModels+"]?: LoadCLIPSegModels_;
        ["DrawText+"]?: DrawText_;
        ["BatchCount+"]?: BatchCount_;
        ["ConsoleDebug+"]?: ConsoleDebug_;
        ["DebugTensorShape+"]?: DebugTensorShape_;
        DisplayAny?: DisplayAny;
        ["ModelCompile+"]?: ModelCompile_;
        ["RemoveLatentMask+"]?: RemoveLatentMask_;
        ["SDXLEmptyLatentSizePicker+"]?: SDXLEmptyLatentSizePicker_;
        ["SimpleComparison+"]?: SimpleComparison_;
        ["SimpleCondition+"]?: SimpleCondition_;
        ["SimpleMath+"]?: SimpleMath_;
        ["SimpleMathDual+"]?: SimpleMathDual_;
        ["SimpleMathCondition+"]?: SimpleMathCondition_;
        ["SimpleMathBoolean+"]?: SimpleMathBoolean_;
        ["SimpleMathFloat+"]?: SimpleMathFloat_;
        ["SimpleMathInt+"]?: SimpleMathInt_;
        ["SimpleMathPercent+"]?: SimpleMathPercent_;
        ["SimpleMathSlider+"]?: SimpleMathSlider_;
        ["SimpleMathSliderLowRes+"]?: SimpleMathSliderLowRes_;
        FaceEmbedDistance?: FaceEmbedDistance;
        FaceAnalysisModels?: FaceAnalysisModels;
        FaceBoundingBox?: FaceBoundingBox;
        FaceAlign?: FaceAlign;
        FaceSegmentation?: FaceSegmentation;
        FaceWarp?: FaceWarp;
        IPAdapter?: IPAdapter;
        IPAdapterAdvanced?: IPAdapterAdvanced;
        IPAdapterBatch?: IPAdapterBatch;
        IPAdapterFaceID?: IPAdapterFaceID;
        IPAAdapterFaceIDBatch?: IPAAdapterFaceIDBatch;
        IPAdapterTiled?: IPAdapterTiled;
        IPAdapterTiledBatch?: IPAdapterTiledBatch;
        IPAdapterEmbeds?: IPAdapterEmbeds;
        IPAdapterEmbedsBatch?: IPAdapterEmbedsBatch;
        IPAdapterStyleComposition?: IPAdapterStyleComposition;
        IPAdapterStyleCompositionBatch?: IPAdapterStyleCompositionBatch;
        IPAdapterMS?: IPAdapterMS;
        IPAdapterFromParams?: IPAdapterFromParams;
        IPAdapterUnifiedLoader?: IPAdapterUnifiedLoader;
        IPAdapterUnifiedLoaderFaceID?: IPAdapterUnifiedLoaderFaceID;
        IPAdapterModelLoader?: IPAdapterModelLoader;
        IPAdapterInsightFaceLoader?: IPAdapterInsightFaceLoader;
        IPAdapterUnifiedLoaderCommunity?: IPAdapterUnifiedLoaderCommunity;
        IPAdapterEncoder?: IPAdapterEncoder;
        IPAdapterCombineEmbeds?: IPAdapterCombineEmbeds;
        IPAdapterNoise?: IPAdapterNoise;
        PrepImageForClipVision?: PrepImageForClipVision;
        IPAdapterSaveEmbeds?: IPAdapterSaveEmbeds;
        IPAdapterLoadEmbeds?: IPAdapterLoadEmbeds;
        IPAdapterWeights?: IPAdapterWeights;
        IPAdapterCombineWeights?: IPAdapterCombineWeights;
        IPAdapterWeightsFromStrategy?: IPAdapterWeightsFromStrategy;
        IPAdapterPromptScheduleFromWeightsStrategy?: IPAdapterPromptScheduleFromWeightsStrategy;
        IPAdapterRegionalConditioning?: IPAdapterRegionalConditioning;
        IPAdapterCombineParams?: IPAdapterCombineParams;
        ["LayerFilter: AddGrain"]?: LayerFilter__AddGrain;
        ["LayerUtility: BatchSelector"]?: LayerUtility__BatchSelector;
        ["LayerMask: BenUltra"]?: LayerMask__BenUltra;
        ["LayerMask: LoadBenModel"]?: LayerMask__LoadBenModel;
        ["LayerMask: BiRefNetUltra"]?: LayerMask__BiRefNetUltra;
        ["LayerMask: BiRefNetUltraV2"]?: LayerMask__BiRefNetUltraV2;
        ["LayerMask: LoadBiRefNetModel"]?: LayerMask__LoadBiRefNetModel;
        ["LayerMask: LoadBiRefNetModelV2"]?: LayerMask__LoadBiRefNetModelV2;
        ["LayerMask: BlendIf Mask"]?: LayerMask__BlendIf_Mask;
        ["LayerFilter: ChannelShake"]?: LayerFilter__ChannelShake;
        ["LayerUtility: CheckMask"]?: LayerUtility__CheckMask;
        ["LayerUtility: CheckMaskV2"]?: LayerUtility__CheckMaskV2;
        ["LayerColor: ColorAdapter"]?: LayerColor__ColorAdapter;
        ["LayerColor: AutoAdjust"]?: LayerColor__AutoAdjust;
        ["LayerColor: AutoAdjustV2"]?: LayerColor__AutoAdjustV2;
        ["LayerColor: AutoBrightness"]?: LayerColor__AutoBrightness;
        ["LayerColor: Brightness & Contrast"]?: LayerColor__Brightness___Contrast;
        ["LayerColor: BrightnessContrastV2"]?: LayerColor__BrightnessContrastV2;
        ["LayerColor: ColorBalance"]?: LayerColor__ColorBalance;
        ["LayerColor: ColorTemperature"]?: LayerColor__ColorTemperature;
        ["LayerColor: Exposure"]?: LayerColor__Exposure;
        ["LayerColor: Gamma"]?: LayerColor__Gamma;
        ["LayerColor: HSV"]?: LayerColor__HSV;
        ["LayerColor: LAB"]?: LayerColor__LAB;
        ["LayerColor: Levels"]?: LayerColor__Levels;
        ["LayerColor: LUT Apply"]?: LayerColor__LUT_Apply;
        ["LayerColor: RGB"]?: LayerColor__RGB;
        ["LayerColor: Color of Shadow & Highlight"]?: LayerColor__Color_of_Shadow___Highlight;
        ["LayerColor: ColorofShadowHighlightV2"]?: LayerColor__ColorofShadowHighlightV2;
        ["LayerColor: YUV"]?: LayerColor__YUV;
        ["LayerUtility: ColorImage"]?: LayerUtility__ColorImage;
        ["LayerUtility: ColorImage V2"]?: LayerUtility__ColorImage_V2;
        ["LayerFilter: ColorMap"]?: LayerFilter__ColorMap;
        ["LayerUtility: ColorName"]?: LayerUtility__ColorName;
        ["LayerStyle: ColorOverlay V2"]?: LayerStyle__ColorOverlay_V2;
        ["LayerStyle: ColorOverlay"]?: LayerStyle__ColorOverlay;
        ["LayerUtility: ColorPicker"]?: LayerUtility__ColorPicker;
        ["LayerUtility: GrayValue"]?: LayerUtility__GrayValue;
        ["LayerUtility: HSV Value"]?: LayerUtility__HSV_Value;
        ["LayerUtility: RGB Value"]?: LayerUtility__RGB_Value;
        ["LayerMask: CreateGradientMask"]?: LayerMask__CreateGradientMask;
        ["LayerUtility: CropBoxResolve"]?: LayerUtility__CropBoxResolve;
        ["LayerUtility: CropByMask"]?: LayerUtility__CropByMask;
        ["LayerUtility: CropByMask V2"]?: LayerUtility__CropByMask_V2;
        ["LayerUtility: QueueStop"]?: LayerUtility__QueueStop;
        ["LayerUtility: SwitchCase"]?: LayerUtility__SwitchCase;
        ["LayerUtility: If "]?: LayerUtility__If_;
        ["LayerUtility: StringCondition"]?: LayerUtility__StringCondition;
        ["LayerUtility: BooleanOperator"]?: LayerUtility__BooleanOperator;
        ["LayerUtility: NumberCalculator"]?: LayerUtility__NumberCalculator;
        ["LayerUtility: BooleanOperatorV2"]?: LayerUtility__BooleanOperatorV2;
        ["LayerUtility: NumberCalculatorV2"]?: LayerUtility__NumberCalculatorV2;
        ["LayerUtility: TextBox"]?: LayerUtility__TextBox;
        ["LayerUtility: String"]?: LayerUtility__String;
        ["LayerUtility: Integer"]?: LayerUtility__Integer;
        ["LayerUtility: Float"]?: LayerUtility__Float;
        ["LayerUtility: Boolean"]?: LayerUtility__Boolean;
        ["LayerUtility: Seed"]?: LayerUtility__Seed;
        ["LayerStyle: DropShadow"]?: LayerStyle__DropShadow;
        ["LayerStyle: DropShadow V2"]?: LayerStyle__DropShadow_V2;
        ["LayerMask: EVFSAMUltra"]?: LayerMask__EVFSAMUltra;
        ["LayerUtility: ExtendCanvas"]?: LayerUtility__ExtendCanvas;
        ["LayerUtility: ExtendCanvasV2"]?: LayerUtility__ExtendCanvasV2;
        ["LayerFilter: Film"]?: LayerFilter__Film;
        ["LayerFilter: FilmV2"]?: LayerFilter__FilmV2;
        ["LayerMask: Florence2Ultra"]?: LayerMask__Florence2Ultra;
        ["LayerMask: LoadFlorence2Model"]?: LayerMask__LoadFlorence2Model;
        ["LayerUtility: Florence2Image2Prompt"]?: LayerUtility__Florence2Image2Prompt;
        ["LayerFilter: GaussianBlur"]?: LayerFilter__GaussianBlur;
        ["LayerFilter: GaussianBlurV2"]?: LayerFilter__GaussianBlurV2;
        ["LayerUtility: GetColorTone"]?: LayerUtility__GetColorTone;
        ["LayerUtility: GetColorToneV2"]?: LayerUtility__GetColorToneV2;
        ["LayerUtility: GetImageSize"]?: LayerUtility__GetImageSize;
        ["LayerUtility: GetMainColors"]?: LayerUtility__GetMainColors;
        ["LayerUtility: GradientImage"]?: LayerUtility__GradientImage;
        ["LayerUtility: GradientImage V2"]?: LayerUtility__GradientImage_V2;
        ["LayerStyle: Gradient Map"]?: LayerStyle__Gradient_Map;
        ["LayerStyle: GradientOverlay"]?: LayerStyle__GradientOverlay;
        ["LayerStyle: GradientOverlay V2"]?: LayerStyle__GradientOverlay_V2;
        ["LayerFilter: HDREffects"]?: LayerFilter__HDREffects;
        ["LayerUtility: HLFrequencyDetailRestore"]?: LayerUtility__HLFrequencyDetailRestore;
        ["LayerMask: HumanPartsUltra"]?: LayerMask__HumanPartsUltra;
        ["LayerUtility: ImageAutoCrop"]?: LayerUtility__ImageAutoCrop;
        ["LayerUtility: ImageAutoCrop V2"]?: LayerUtility__ImageAutoCrop_V2;
        ["LayerUtility: ImageAutoCrop V3"]?: LayerUtility__ImageAutoCrop_V3;
        ["LayerUtility: ImageBlend"]?: LayerUtility__ImageBlend;
        ["LayerUtility: ImageBlendAdvance"]?: LayerUtility__ImageBlendAdvance;
        ["LayerUtility: ImageBlendAdvance V2"]?: LayerUtility__ImageBlendAdvance_V2;
        ["LayerUtility: ImageBlend V2"]?: LayerUtility__ImageBlend_V2;
        ["LayerUtility: ImageChannelMerge"]?: LayerUtility__ImageChannelMerge;
        ["LayerUtility: ImageChannelSplit"]?: LayerUtility__ImageChannelSplit;
        ["LayerUtility: ImageCombineAlpha"]?: LayerUtility__ImageCombineAlpha;
        ["LayerUtility: ImageHub"]?: LayerUtility__ImageHub;
        ["LayerUtility: ImageMaskScaleAs"]?: LayerUtility__ImageMaskScaleAs;
        ["LayerUtility: ImageOpacity"]?: LayerUtility__ImageOpacity;
        ["LayerUtility: ImageReel"]?: LayerUtility__ImageReel;
        ["LayerUtility: ImageReelComposit"]?: LayerUtility__ImageReelComposit;
        ["LayerUtility: ImageRemoveAlpha"]?: LayerUtility__ImageRemoveAlpha;
        ["LayerUtility: ImageRewardFilter"]?: LayerUtility__ImageRewardFilter;
        ["LayerUtility: ImageScaleByAspectRatio"]?: LayerUtility__ImageScaleByAspectRatio;
        ["LayerUtility: ImageScaleByAspectRatio V2"]?: LayerUtility__ImageScaleByAspectRatio_V2;
        ["LayerUtility: ImageScaleRestore"]?: LayerUtility__ImageScaleRestore;
        ["LayerUtility: ImageScaleRestore V2"]?: LayerUtility__ImageScaleRestore_V2;
        ["LayerUtility: ImageShift"]?: LayerUtility__ImageShift;
        ["LayerUtility: ImageTaggerSave"]?: LayerUtility__ImageTaggerSave;
        ["LayerMask: ImageToMask"]?: LayerMask__ImageToMask;
        ["LayerStyle: InnerGlow"]?: LayerStyle__InnerGlow;
        ["LayerStyle: InnerGlow V2"]?: LayerStyle__InnerGlow_V2;
        ["LayerStyle: InnerShadow"]?: LayerStyle__InnerShadow;
        ["LayerStyle: InnerShadow V2"]?: LayerStyle__InnerShadow_V2;
        ["LayerUtility: LoadJoyCaption2Model"]?: LayerUtility__LoadJoyCaption2Model;
        ["LayerUtility: JoyCaption2Split"]?: LayerUtility__JoyCaption2Split;
        ["LayerUtility: JoyCaption2"]?: LayerUtility__JoyCaption2;
        ["LayerUtility: JoyCaption2ExtraOptions"]?: LayerUtility__JoyCaption2ExtraOptions;
        ["LayerUtility: LaMa"]?: LayerUtility__LaMa;
        ["LayerUtility: LayerImageTransform"]?: LayerUtility__LayerImageTransform;
        ["LayerUtility: LayerMaskTransform"]?: LayerUtility__LayerMaskTransform;
        ["LayerFilter: LightLeak"]?: LayerFilter__LightLeak;
        ["LayerUtility: LlamaVision"]?: LayerUtility__LlamaVision;
        ["LayerUtility: LoadPSD"]?: LayerUtility__LoadPSD;
        ["LayerMask: MaskBoxDetect"]?: LayerMask__MaskBoxDetect;
        ["LayerMask: MaskByColor"]?: LayerMask__MaskByColor;
        ["LayerMask: MaskByDifferent"]?: LayerMask__MaskByDifferent;
        ["LayerMask: MaskEdgeShrink"]?: LayerMask__MaskEdgeShrink;
        ["LayerMask: MaskEdgeUltraDetail"]?: LayerMask__MaskEdgeUltraDetail;
        ["LayerMask: MaskEdgeUltraDetail V2"]?: LayerMask__MaskEdgeUltraDetail_V2;
        ["LayerMask: MaskGradient"]?: LayerMask__MaskGradient;
        ["LayerMask: MaskGrain"]?: LayerMask__MaskGrain;
        ["LayerMask: MaskGrow"]?: LayerMask__MaskGrow;
        ["LayerMask: MaskInvert"]?: LayerMask__MaskInvert;
        ["LayerMask: MaskMotionBlur"]?: LayerMask__MaskMotionBlur;
        ["LayerMask: MaskPreview"]?: LayerMask__MaskPreview;
        ["LayerMask: MaskStroke"]?: LayerMask__MaskStroke;
        ["LayerMask: MediapipeFacialSegment"]?: LayerMask__MediapipeFacialSegment;
        ["LayerFilter: MotionBlur"]?: LayerFilter__MotionBlur;
        ["LayerMask: BBoxJoin"]?: LayerMask__BBoxJoin;
        ["LayerMask: DrawBBoxMask"]?: LayerMask__DrawBBoxMask;
        ["LayerMask: ObjectDetectorFL2"]?: LayerMask__ObjectDetectorFL2;
        ["LayerMask: ObjectDetectorMask"]?: LayerMask__ObjectDetectorMask;
        ["LayerMask: ObjectDetectorYOLO8"]?: LayerMask__ObjectDetectorYOLO8;
        ["LayerMask: ObjectDetectorYOLOWorld"]?: LayerMask__ObjectDetectorYOLOWorld;
        ["LayerStyle: OuterGlow"]?: LayerStyle__OuterGlow;
        ["LayerStyle: OuterGlow V2"]?: LayerStyle__OuterGlow_V2;
        ["LayerMask: PersonMaskUltra"]?: LayerMask__PersonMaskUltra;
        ["LayerMask: PersonMaskUltra V2"]?: LayerMask__PersonMaskUltra_V2;
        ["LayerUtility: PhiPrompt"]?: LayerUtility__PhiPrompt;
        ["LayerMask: PixelSpread"]?: LayerMask__PixelSpread;
        ["LayerUtility: PrintInfo"]?: LayerUtility__PrintInfo;
        ["LayerUtility: PromptEmbellish"]?: LayerUtility__PromptEmbellish;
        ["LayerUtility: PromptTagger"]?: LayerUtility__PromptTagger;
        ["LayerUtility: PurgeVRAM"]?: LayerUtility__PurgeVRAM;
        ["LayerUtility: CreateQRCode"]?: LayerUtility__CreateQRCode;
        ["LayerUtility: DecodeQRCode"]?: LayerUtility__DecodeQRCode;
        ["LayerUtility: QWenImage2Prompt"]?: LayerUtility__QWenImage2Prompt;
        ["LayerUtility: RandomGenerator"]?: LayerUtility__RandomGenerator;
        ["LayerUtility: RandomGeneratorV2"]?: LayerUtility__RandomGeneratorV2;
        ["LayerUtility: RestoreCropBox"]?: LayerUtility__RestoreCropBox;
        ["LayerMask: RemBgUltra"]?: LayerMask__RemBgUltra;
        ["LayerMask: RmBgUltra V2"]?: LayerMask__RmBgUltra_V2;
        ["LayerMask: SAM2Ultra"]?: LayerMask__SAM2Ultra;
        ["LayerMask: SAM2VideoUltra"]?: LayerMask__SAM2VideoUltra;
        ["LayerUtility: SaveImagePlus"]?: LayerUtility__SaveImagePlus;
        ["LayerUtility: SD3NegativeConditioning"]?: LayerUtility__SD3NegativeConditioning;
        ["LayerMask: SegformerB2ClothesUltra"]?: LayerMask__SegformerB2ClothesUltra;
        ["LayerMask: SegformerUltraV2"]?: LayerMask__SegformerUltraV2;
        ["LayerMask: SegformerClothesPipelineLoader"]?: LayerMask__SegformerClothesPipelineLoader;
        ["LayerMask: SegformerFashionPipelineLoader"]?: LayerMask__SegformerFashionPipelineLoader;
        ["LayerMask: SegmentAnythingUltra"]?: LayerMask__SegmentAnythingUltra;
        ["LayerMask: SegmentAnythingUltra V2"]?: LayerMask__SegmentAnythingUltra_V2;
        ["LayerMask: Shadow & Highlight Mask"]?: LayerMask__Shadow___Highlight_Mask;
        ["LayerMask: ShadowHighlightMaskV2"]?: LayerMask__ShadowHighlightMaskV2;
        ["LayerFilter: Sharp & Soft"]?: LayerFilter__Sharp___Soft;
        ["LayerUtility: SimpleTextImage"]?: LayerUtility__SimpleTextImage;
        ["LayerFilter: SkinBeauty"]?: LayerFilter__SkinBeauty;
        ["LayerFilter: SoftLight"]?: LayerFilter__SoftLight;
        ["LayerStyle: Stroke"]?: LayerStyle__Stroke;
        ["LayerStyle: Stroke V2"]?: LayerStyle__Stroke_V2;
        ["LayerUtility: TextImage"]?: LayerUtility__TextImage;
        ["LayerUtility: TextImage V2"]?: LayerUtility__TextImage_V2;
        ["LayerUtility: TextJoin"]?: LayerUtility__TextJoin;
        ["LayerUtility: TextJoinV2"]?: LayerUtility__TextJoinV2;
        ["LayerMask: TransparentBackgroundUltra"]?: LayerMask__TransparentBackgroundUltra;
        ["LayerUtility: UserPromptGeneratorTxt2ImgPrompt"]?: LayerUtility__UserPromptGeneratorTxt2ImgPrompt;
        ["LayerUtility: UserPromptGeneratorTxt2ImgPromptWithReference"]?: LayerUtility__UserPromptGeneratorTxt2ImgPromptWithReference;
        ["LayerUtility: UserPromptGeneratorReplaceWord"]?: LayerUtility__UserPromptGeneratorReplaceWord;
        ["LayerUtility: VQAPrompt"]?: LayerUtility__VQAPrompt;
        ["LayerUtility: LoadVQAModel"]?: LayerUtility__LoadVQAModel;
        ["LayerUtility: AddBlindWaterMark"]?: LayerUtility__AddBlindWaterMark;
        ["LayerUtility: ShowBlindWaterMark"]?: LayerUtility__ShowBlindWaterMark;
        ["LayerFilter: WaterColor"]?: LayerFilter__WaterColor;
        ["LayerUtility: XY to Percent"]?: LayerUtility__XY_to_Percent;
        ["LayerMask: YoloV8Detect"]?: LayerMask__YoloV8Detect;
        ["LayerUtility: Collage"]?: LayerUtility__Collage;
        ["LayerUtility: DeepSeekAPI"]?: LayerUtility__DeepSeekAPI;
        ["LayerUtility: DeepSeekAPIV2"]?: LayerUtility__DeepSeekAPIV2;
        ["LayerUtility: Gemini"]?: LayerUtility__Gemini;
        ["LayerUtility: GeminiV2"]?: LayerUtility__GeminiV2;
        ["LayerMask: ObjectDetectorGemini"]?: LayerMask__ObjectDetectorGemini;
        ["LayerMask: ObjectDetectorGeminiV2"]?: LayerMask__ObjectDetectorGeminiV2;
        ["LayerUtility: GeminiImageEdit"]?: LayerUtility__GeminiImageEdit;
        ["LayerUtility: JoyCaptionBeta1"]?: LayerUtility__JoyCaptionBeta1;
        ["LayerUtility: LoadJoyCaptionBeta1Model"]?: LayerUtility__LoadJoyCaptionBeta1Model;
        ["LayerUtility: JoyCaptionBeta1ExtraOptions"]?: LayerUtility__JoyCaptionBeta1ExtraOptions;
        ["LayerMask: DrawBBoxMaskV2"]?: LayerMask__DrawBBoxMaskV2;
        ["LayerMask: SAM2UltraV2"]?: LayerMask__SAM2UltraV2;
        ["LayerMask: LoadSAM2Model"]?: LayerMask__LoadSAM2Model;
        ["LayerUtility: SaveImagePlusV2"]?: LayerUtility__SaveImagePlusV2;
        ["LayerMask: SegmentAnythingUltra V3"]?: LayerMask__SegmentAnythingUltra_V3;
        ["LayerMask: LoadSegmentAnythingModels"]?: LayerMask__LoadSegmentAnythingModels;
        ["LayerUtility: LoadSmolLM2Model"]?: LayerUtility__LoadSmolLM2Model;
        ["LayerUtility: LoadSmolVLMModel"]?: LayerUtility__LoadSmolVLMModel;
        ["LayerUtility: SmolLM2"]?: LayerUtility__SmolLM2;
        ["LayerUtility: SmolVLM"]?: LayerUtility__SmolVLM;
        ["LayerUtility: ZhipuGLM4V"]?: LayerUtility__ZhipuGLM4V;
        ["LayerUtility: ZhipuGLM4"]?: LayerUtility__ZhipuGLM4;
        segformer_b2_clothes?: segformer_b2_clothes;
        segformer_b3_fashion?: segformer_b3_fashion;
        UltimateSDUpscale?: UltimateSDUpscale;
        UltimateSDUpscaleNoUpscale?: UltimateSDUpscaleNoUpscale;
        UltimateSDUpscaleCustomSample?: UltimateSDUpscaleCustomSample;
        ["KSampler (Efficient)"]?: KSampler__Efficient_;
        ["KSampler Adv. (Efficient)"]?: KSampler_Adv___Efficient_;
        ["KSampler SDXL (Eff.)"]?: KSampler_SDXL__Eff__;
        ["Efficient Loader"]?: Efficient_Loader;
        ["Eff. Loader SDXL"]?: Eff__Loader_SDXL;
        ["LoRA Stacker"]?: LoRA_Stacker;
        ["Control Net Stacker"]?: Control_Net_Stacker;
        ["Apply ControlNet Stack"]?: Apply_ControlNet_Stack;
        ["Unpack SDXL Tuple"]?: Unpack_SDXL_Tuple;
        ["Pack SDXL Tuple"]?: Pack_SDXL_Tuple;
        ["XY Plot"]?: XY_Plot;
        ["XY Input: Seeds++ Batch"]?: XY_Input__Seeds___Batch;
        ["XY Input: Add/Return Noise"]?: XY_Input__Add_Return_Noise;
        ["XY Input: Steps"]?: XY_Input__Steps;
        ["XY Input: CFG Scale"]?: XY_Input__CFG_Scale;
        ["XY Input: Sampler/Scheduler"]?: XY_Input__Sampler_Scheduler;
        ["XY Input: Denoise"]?: XY_Input__Denoise;
        ["XY Input: VAE"]?: XY_Input__VAE;
        ["XY Input: Prompt S/R"]?: XY_Input__Prompt_S_R;
        ["XY Input: Aesthetic Score"]?: XY_Input__Aesthetic_Score;
        ["XY Input: Refiner On/Off"]?: XY_Input__Refiner_On_Off;
        ["XY Input: Checkpoint"]?: XY_Input__Checkpoint;
        ["XY Input: Clip Skip"]?: XY_Input__Clip_Skip;
        ["XY Input: LoRA"]?: XY_Input__LoRA;
        ["XY Input: LoRA Plot"]?: XY_Input__LoRA_Plot;
        ["XY Input: LoRA Stacks"]?: XY_Input__LoRA_Stacks;
        ["XY Input: Control Net"]?: XY_Input__Control_Net;
        ["XY Input: Control Net Plot"]?: XY_Input__Control_Net_Plot;
        ["XY Input: Manual XY Entry"]?: XY_Input__Manual_XY_Entry;
        ["Join XY Inputs of Same Type"]?: Join_XY_Inputs_of_Same_Type;
        ["Image Overlay"]?: Image_Overlay;
        ["Noise Control Script"]?: Noise_Control_Script;
        ["HighRes-Fix Script"]?: HighRes_Fix_Script;
        ["Tiled Upscaler Script"]?: Tiled_Upscaler_Script;
        ["LoRA Stack to String converter"]?: LoRA_Stack_to_String_converter;
        ["Evaluate Integers"]?: Evaluate_Integers;
        ["Evaluate Floats"]?: Evaluate_Floats;
        ["Evaluate Strings"]?: Evaluate_Strings;
        LoaderGGUF?: LoaderGGUF;
        ClipLoaderGGUF?: ClipLoaderGGUF;
        DualClipLoaderGGUF?: DualClipLoaderGGUF;
        TripleClipLoaderGGUF?: TripleClipLoaderGGUF;
        QuadrupleClipLoaderGGUF?: QuadrupleClipLoaderGGUF;
        AudioEncoderLoaderGGUF?: AudioEncoderLoaderGGUF;
        LoaderGGUFAdvanced?: LoaderGGUFAdvanced;
        VaeGGUF?: VaeGGUF;
        GGUFUndo?: GGUFUndo;
        GGUFSave?: GGUFSave;
        GGUFRun?: GGUFRun;
        TENSORCut?: TENSORCut;
        TENSORBoost?: TENSORBoost;
        InContextEditInstruction?: InContextEditInstruction;
        DiptychCreate?: DiptychCreate;
        ICEFConditioning?: ICEFConditioning;
        ["Mask By Text"]?: Mask_By_Text;
        ["Mask Morphology"]?: Mask_Morphology;
        ["Combine Masks"]?: Combine_Masks;
        ["Unary Mask Op"]?: Unary_Mask_Op;
        ["Unary Image Op"]?: Unary_Image_Op;
        Blur?: Blur;
        ["Image To Mask"]?: Image_To_Mask;
        ["Mix Images By Mask"]?: Mix_Images_By_Mask;
        ["Mix Color By Mask"]?: Mix_Color_By_Mask;
        ["Mask To Region"]?: Mask_To_Region;
        ["Cut By Mask"]?: Cut_By_Mask;
        ["Paste By Mask"]?: Paste_By_Mask;
        ["Get Image Size"]?: Get_Image_Size;
        ["Change Channel Count"]?: Change_Channel_Count;
        ["Constant Mask"]?: Constant_Mask;
        ["Prune By Mask"]?: Prune_By_Mask;
        ["Separate Mask Components"]?: Separate_Mask_Components;
        ["Create Rect Mask"]?: Create_Rect_Mask;
        ["Make Image Batch"]?: Make_Image_Batch;
        ["Create QR Code"]?: Create_QR_Code;
        ["Convert Color Space"]?: Convert_Color_Space;
        MasqueradeIncrementer?: MasqueradeIncrementer;
        ["BLIP Model Loader"]?: BLIP_Model_Loader;
        ["Blend Latents"]?: Blend_Latents;
        ["Bus Node"]?: Bus_Node;
        ["Cache Node"]?: Cache_Node;
        ["Checkpoint Loader"]?: Checkpoint_Loader;
        ["Checkpoint Loader (Simple)"]?: Checkpoint_Loader__Simple_;
        ["CLIPTextEncode (NSP)"]?: CLIPTextEncode__NSP_;
        ["CLIP Input Switch"]?: CLIP_Input_Switch;
        ["CLIP Vision Input Switch"]?: CLIP_Vision_Input_Switch;
        ["Conditioning Input Switch"]?: Conditioning_Input_Switch;
        ["Constant Number"]?: Constant_Number;
        ["Create Grid Image"]?: Create_Grid_Image;
        ["Create Grid Image from Batch"]?: Create_Grid_Image_from_Batch;
        ["Create Morph Image"]?: Create_Morph_Image;
        ["Create Morph Image from Path"]?: Create_Morph_Image_from_Path;
        ["Create Video from Path"]?: Create_Video_from_Path;
        ["CLIPSeg Masking"]?: CLIPSeg_Masking;
        ["CLIPSeg Model Loader"]?: CLIPSeg_Model_Loader;
        ["CLIPSeg Batch Masking"]?: CLIPSeg_Batch_Masking;
        ["Convert Masks to Images"]?: Convert_Masks_to_Images;
        ["Control Net Model Input Switch"]?: Control_Net_Model_Input_Switch;
        ["Debug Number to Console"]?: Debug_Number_to_Console;
        ["Dictionary to Console"]?: Dictionary_to_Console;
        ["Diffusers Model Loader"]?: Diffusers_Model_Loader;
        ["Diffusers Hub Model Down-Loader"]?: Diffusers_Hub_Model_Down_Loader;
        ["Export API"]?: Export_API;
        ["Latent Input Switch"]?: Latent_Input_Switch;
        ["Load Cache"]?: Load_Cache;
        ["Logic Boolean"]?: Logic_Boolean;
        ["Logic Boolean Primitive"]?: Logic_Boolean_Primitive;
        ["Logic Comparison OR"]?: Logic_Comparison_OR;
        ["Logic Comparison AND"]?: Logic_Comparison_AND;
        ["Logic Comparison XOR"]?: Logic_Comparison_XOR;
        ["Logic NOT"]?: Logic_NOT;
        ["Lora Loader"]?: Lora_Loader;
        ["Hex to HSL"]?: Hex_to_HSL;
        ["HSL to Hex"]?: HSL_to_Hex;
        ["Image SSAO (Ambient Occlusion)"]?: Image_SSAO__Ambient_Occlusion_;
        ["Image SSDO (Direct Occlusion)"]?: Image_SSDO__Direct_Occlusion_;
        ["Image Analyze"]?: Image_Analyze;
        ["Image Aspect Ratio"]?: Image_Aspect_Ratio;
        ["Image Batch"]?: Image_Batch;
        ["Image Blank"]?: Image_Blank;
        ["Image Blend by Mask"]?: Image_Blend_by_Mask;
        ["Image Blend"]?: Image_Blend;
        ["Image Blending Mode"]?: Image_Blending_Mode;
        ["Image Bloom Filter"]?: Image_Bloom_Filter;
        ["Image Canny Filter"]?: Image_Canny_Filter;
        ["Image Chromatic Aberration"]?: Image_Chromatic_Aberration;
        ["Image Color Palette"]?: Image_Color_Palette;
        ["Image Crop Face"]?: Image_Crop_Face;
        ["Image Crop Location"]?: Image_Crop_Location;
        ["Image Crop Square Location"]?: Image_Crop_Square_Location;
        ["Image Displacement Warp"]?: Image_Displacement_Warp;
        ["Image Lucy Sharpen"]?: Image_Lucy_Sharpen;
        ["Image Paste Face"]?: Image_Paste_Face;
        ["Image Paste Crop"]?: Image_Paste_Crop;
        ["Image Paste Crop by Location"]?: Image_Paste_Crop_by_Location;
        ["Image Pixelate"]?: Image_Pixelate;
        ["Image Power Noise"]?: Image_Power_Noise;
        ["Image Dragan Photography Filter"]?: Image_Dragan_Photography_Filter;
        ["Image Edge Detection Filter"]?: Image_Edge_Detection_Filter;
        ["Image Film Grain"]?: Image_Film_Grain;
        ["Image Filter Adjustments"]?: Image_Filter_Adjustments;
        ["Image Flip"]?: Image_Flip;
        ["Image Gradient Map"]?: Image_Gradient_Map;
        ["Image Generate Gradient"]?: Image_Generate_Gradient;
        ["Image High Pass Filter"]?: Image_High_Pass_Filter;
        ["Image History Loader"]?: Image_History_Loader;
        ["Image Input Switch"]?: Image_Input_Switch;
        ["Image Levels Adjustment"]?: Image_Levels_Adjustment;
        ["Image Load"]?: Image_Load;
        ["Image Median Filter"]?: Image_Median_Filter;
        ["Image Mix RGB Channels"]?: Image_Mix_RGB_Channels;
        ["Image Monitor Effects Filter"]?: Image_Monitor_Effects_Filter;
        ["Image Nova Filter"]?: Image_Nova_Filter;
        ["Image Padding"]?: Image_Padding;
        ["Image Perlin Noise"]?: Image_Perlin_Noise;
        ["Image Rembg (Remove Background)"]?: Image_Rembg__Remove_Background_;
        ["Image Perlin Power Fractal"]?: Image_Perlin_Power_Fractal;
        ["Image Remove Background (Alpha)"]?: Image_Remove_Background__Alpha_;
        ["Image Remove Color"]?: Image_Remove_Color;
        ["Image Resize"]?: Image_Resize;
        ["Image Rotate"]?: Image_Rotate;
        ["Image Rotate Hue"]?: Image_Rotate_Hue;
        ["Image Send HTTP"]?: Image_Send_HTTP;
        ["Image Save"]?: Image_Save;
        ["Image Seamless Texture"]?: Image_Seamless_Texture;
        ["Image Select Channel"]?: Image_Select_Channel;
        ["Image Select Color"]?: Image_Select_Color;
        ["Image Shadows and Highlights"]?: Image_Shadows_and_Highlights;
        ["Image Size to Number"]?: Image_Size_to_Number;
        ["Image Stitch"]?: Image_Stitch;
        ["Image Style Filter"]?: Image_Style_Filter;
        ["Image Threshold"]?: Image_Threshold;
        ["Image Tiled"]?: Image_Tiled;
        ["Image Transpose"]?: Image_Transpose;
        ["Image fDOF Filter"]?: Image_fDOF_Filter;
        ["Image to Latent Mask"]?: Image_to_Latent_Mask;
        ["Image to Noise"]?: Image_to_Noise;
        ["Image to Seed"]?: Image_to_Seed;
        ["Images to RGB"]?: Images_to_RGB;
        ["Images to Linear"]?: Images_to_Linear;
        ["Integer place counter"]?: Integer_place_counter;
        ["Image Voronoi Noise Filter"]?: Image_Voronoi_Noise_Filter;
        ["KSampler (WAS)"]?: KSampler__WAS_;
        ["KSampler Cycle"]?: KSampler_Cycle;
        ["Latent Batch"]?: Latent_Batch;
        ["Latent Noise Injection"]?: Latent_Noise_Injection;
        ["Latent Size to Number"]?: Latent_Size_to_Number;
        ["Latent Upscale by Factor (WAS)"]?: Latent_Upscale_by_Factor__WAS_;
        ["Load Image Batch"]?: Load_Image_Batch;
        ["Load Text File"]?: Load_Text_File;
        ["Load Lora"]?: Load_Lora;
        ["Lora Input Switch"]?: Lora_Input_Switch;
        ["Masks Add"]?: Masks_Add;
        ["Masks Subtract"]?: Masks_Subtract;
        ["Mask Arbitrary Region"]?: Mask_Arbitrary_Region;
        ["Mask Batch to Mask"]?: Mask_Batch_to_Mask;
        ["Mask Batch"]?: Mask_Batch;
        ["Mask Ceiling Region"]?: Mask_Ceiling_Region;
        ["Mask Crop Dominant Region"]?: Mask_Crop_Dominant_Region;
        ["Mask Crop Minority Region"]?: Mask_Crop_Minority_Region;
        ["Mask Crop Region"]?: Mask_Crop_Region;
        ["Mask Paste Region"]?: Mask_Paste_Region;
        ["Mask Dilate Region"]?: Mask_Dilate_Region;
        ["Mask Dominant Region"]?: Mask_Dominant_Region;
        ["Mask Erode Region"]?: Mask_Erode_Region;
        ["Mask Fill Holes"]?: Mask_Fill_Holes;
        ["Mask Floor Region"]?: Mask_Floor_Region;
        ["Mask Gaussian Region"]?: Mask_Gaussian_Region;
        ["Mask Invert"]?: Mask_Invert;
        ["Mask Minority Region"]?: Mask_Minority_Region;
        ["Mask Rect Area"]?: Mask_Rect_Area;
        ["Mask Rect Area (Advanced)"]?: Mask_Rect_Area__Advanced_;
        ["Mask Smooth Region"]?: Mask_Smooth_Region;
        ["Mask Threshold Region"]?: Mask_Threshold_Region;
        ["Masks Combine Regions"]?: Masks_Combine_Regions;
        ["Masks Combine Batch"]?: Masks_Combine_Batch;
        ["MiDaS Model Loader"]?: MiDaS_Model_Loader;
        ["MiDaS Depth Approximation"]?: MiDaS_Depth_Approximation;
        ["MiDaS Mask Image"]?: MiDaS_Mask_Image;
        ["Model Input Switch"]?: Model_Input_Switch;
        ["Number Counter"]?: Number_Counter;
        ["Number Operation"]?: Number_Operation;
        ["Number to Float"]?: Number_to_Float;
        ["Number Input Switch"]?: Number_Input_Switch;
        ["Number Input Condition"]?: Number_Input_Condition;
        ["Number Multiple Of"]?: Number_Multiple_Of;
        ["Number PI"]?: Number_PI;
        ["Number to Int"]?: Number_to_Int;
        ["Number to Seed"]?: Number_to_Seed;
        ["Number to String"]?: Number_to_String;
        ["Number to Text"]?: Number_to_Text;
        ["Boolean To Text"]?: Boolean_To_Text;
        ["Prompt Styles Selector"]?: Prompt_Styles_Selector;
        ["Prompt Multiple Styles Selector"]?: Prompt_Multiple_Styles_Selector;
        ["Random Number"]?: Random_Number;
        ["Save Text File"]?: Save_Text_File;
        Seed?: Seed;
        ["Tensor Batch to Image"]?: Tensor_Batch_to_Image;
        ["BLIP Analyze Image"]?: BLIP_Analyze_Image;
        ["SAM Model Loader"]?: SAM_Model_Loader;
        ["SAM Parameters"]?: SAM_Parameters;
        ["SAM Parameters Combine"]?: SAM_Parameters_Combine;
        ["SAM Image Mask"]?: SAM_Image_Mask;
        ["Samples Passthrough (Stat System)"]?: Samples_Passthrough__Stat_System_;
        ["String to Text"]?: String_to_Text;
        ["Image Bounds"]?: Image_Bounds;
        ["Inset Image Bounds"]?: Inset_Image_Bounds;
        ["Bounded Image Blend"]?: Bounded_Image_Blend;
        ["Bounded Image Blend with Mask"]?: Bounded_Image_Blend_with_Mask;
        ["Bounded Image Crop"]?: Bounded_Image_Crop;
        ["Bounded Image Crop with Mask"]?: Bounded_Image_Crop_with_Mask;
        ["Image Bounds to Console"]?: Image_Bounds_to_Console;
        ["Text Dictionary Update"]?: Text_Dictionary_Update;
        ["Text Dictionary Get"]?: Text_Dictionary_Get;
        ["Text Dictionary Convert"]?: Text_Dictionary_Convert;
        ["Text Dictionary New"]?: Text_Dictionary_New;
        ["Text Dictionary Keys"]?: Text_Dictionary_Keys;
        ["Text Dictionary To Text"]?: Text_Dictionary_To_Text;
        ["Text Add Tokens"]?: Text_Add_Tokens;
        ["Text Add Token by Input"]?: Text_Add_Token_by_Input;
        ["Text Compare"]?: Text_Compare;
        ["Text Concatenate"]?: Text_Concatenate;
        ["Text File History Loader"]?: Text_File_History_Loader;
        ["Text Find and Replace by Dictionary"]?: Text_Find_and_Replace_by_Dictionary;
        ["Text Find and Replace Input"]?: Text_Find_and_Replace_Input;
        ["Text Find and Replace"]?: Text_Find_and_Replace;
        ["Text Find"]?: Text_Find;
        ["Text Input Switch"]?: Text_Input_Switch;
        ["Text List"]?: Text_List;
        ["Text List Concatenate"]?: Text_List_Concatenate;
        ["Text List to Text"]?: Text_List_to_Text;
        ["Text Load Line From File"]?: Text_Load_Line_From_File;
        ["Text Multiline"]?: Text_Multiline;
        ["Text Multiline (Code Compatible)"]?: Text_Multiline__Code_Compatible_;
        ["Text Parse A1111 Embeddings"]?: Text_Parse_A1111_Embeddings;
        ["Text Parse Noodle Soup Prompts"]?: Text_Parse_Noodle_Soup_Prompts;
        ["Text Parse Tokens"]?: Text_Parse_Tokens;
        ["Text Random Line"]?: Text_Random_Line;
        ["Text Random Prompt"]?: Text_Random_Prompt;
        ["Text String"]?: Text_String;
        ["Text Contains"]?: Text_Contains;
        ["Text Shuffle"]?: Text_Shuffle;
        ["Text Sort"]?: Text_Sort;
        ["Text to Conditioning"]?: Text_to_Conditioning;
        ["Text to Console"]?: Text_to_Console;
        ["Text to Number"]?: Text_to_Number;
        ["Text to String"]?: Text_to_String;
        ["Text String Truncate"]?: Text_String_Truncate;
        ["True Random.org Number Generator"]?: True_Random_org_Number_Generator;
        ["unCLIP Checkpoint Loader"]?: unCLIP_Checkpoint_Loader;
        ["Upscale Model Loader"]?: Upscale_Model_Loader;
        ["Upscale Model Switch"]?: Upscale_Model_Switch;
        ["Write to GIF"]?: Write_to_GIF;
        ["Write to Video"]?: Write_to_Video;
        ["VAE Input Switch"]?: VAE_Input_Switch;
        ["Video Dump Frames"]?: Video_Dump_Frames;
        CLIPSEG2?: CLIPSEG2;
        SaveImageWebsocket?: SaveImageWebsocket;
    }
    interface KSampler {
        /**
         * INPUT_TYPES: model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise
         */
        inputs?: {
            model: unknown;
            seed: number;
            steps: number;
            cfg: number;
            sampler_name: string;
            scheduler: string;
            positive: unknown;
            negative: unknown;
            latent_image: unknown;
            denoise: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CheckpointLoaderSimple {
        /**
         * INPUT_TYPES: ckpt_name
         */
        inputs?: {
            ckpt_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, VAE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface CLIPTextEncode {
        /**
         * INPUT_TYPES: text, clip
         */
        inputs?: {
            text: string;
            clip: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPSetLastLayer {
        /**
         * INPUT_TYPES: clip, stop_at_clip_layer
         */
        inputs?: {
            clip: unknown;
            stop_at_clip_layer: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface VAEDecode {
        /**
         * INPUT_TYPES: samples, vae
         */
        inputs?: {
            samples: unknown;
            vae: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface VAEEncode {
        /**
         * INPUT_TYPES: pixels, vae
         */
        inputs?: {
            pixels: unknown;
            vae: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface VAEEncodeForInpaint {
        /**
         * INPUT_TYPES: pixels, vae, mask, grow_mask_by
         */
        inputs?: {
            pixels: unknown;
            vae: unknown;
            mask: unknown;
            grow_mask_by: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface VAELoader {
        /**
         * INPUT_TYPES: vae_name
         */
        inputs?: {
            vae_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: VAE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface EmptyLatentImage {
        /**
         * INPUT_TYPES: width, height, batch_size
         */
        inputs?: {
            width: number;
            height: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentUpscale {
        /**
         * INPUT_TYPES: samples, upscale_method, width, height, crop
         */
        inputs?: {
            samples: unknown;
            upscale_method: string;
            width: number;
            height: number;
            crop: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentUpscaleBy {
        /**
         * INPUT_TYPES: samples, upscale_method, scale_by
         */
        inputs?: {
            samples: unknown;
            upscale_method: string;
            scale_by: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentFromBatch {
        /**
         * INPUT_TYPES: samples, batch_index, length
         */
        inputs?: {
            samples: unknown;
            batch_index: number;
            length: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface RepeatLatentBatch {
        /**
         * INPUT_TYPES: samples, amount
         */
        inputs?: {
            samples: unknown;
            amount: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SaveImage {
        /**
         * INPUT_TYPES: images, filename_prefix
         */
        inputs?: {
            images: unknown;
            filename_prefix: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface PreviewImage {
        /**
         * INPUT_TYPES: images
         */
        inputs?: {
            images: unknown;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface LoadImage {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LoadImageMask {
        /**
         * INPUT_TYPES: image, channel
         */
        inputs?: {
            image: string;
            channel: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LoadImageOutput {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ImageScale {
        /**
         * INPUT_TYPES: image, upscale_method, width, height, crop
         */
        inputs?: {
            image: unknown;
            upscale_method: string;
            width: number;
            height: number;
            crop: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageScaleBy {
        /**
         * INPUT_TYPES: image, upscale_method, scale_by
         */
        inputs?: {
            image: unknown;
            upscale_method: string;
            scale_by: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageInvert {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageBatch {
        /**
         * INPUT_TYPES: image1, image2
         */
        inputs?: {
            image1: unknown;
            image2: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImagePadForOutpaint {
        /**
         * INPUT_TYPES: image, left, top, right, bottom, feathering
         */
        inputs?: {
            image: unknown;
            left: number;
            top: number;
            right: number;
            bottom: number;
            feathering: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface EmptyImage {
        /**
         * INPUT_TYPES: width, height, batch_size, color
         */
        inputs?: {
            width: number;
            height: number;
            batch_size: number;
            color: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ConditioningAverage {
        /**
         * INPUT_TYPES: conditioning_to, conditioning_from, conditioning_to_strength
         */
        inputs?: {
            conditioning_to: unknown;
            conditioning_from: unknown;
            conditioning_to_strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ConditioningCombine {
        /**
         * INPUT_TYPES: conditioning_1, conditioning_2
         */
        inputs?: {
            conditioning_1: unknown;
            conditioning_2: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ConditioningConcat {
        /**
         * INPUT_TYPES: conditioning_to, conditioning_from
         */
        inputs?: {
            conditioning_to: unknown;
            conditioning_from: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ConditioningSetArea {
        /**
         * INPUT_TYPES: conditioning, width, height, x, y, strength
         */
        inputs?: {
            conditioning: unknown;
            width: number;
            height: number;
            x: number;
            y: number;
            strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ConditioningSetAreaPercentage {
        /**
         * INPUT_TYPES: conditioning, width, height, x, y, strength
         */
        inputs?: {
            conditioning: unknown;
            width: number;
            height: number;
            x: number;
            y: number;
            strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ConditioningSetAreaStrength {
        /**
         * INPUT_TYPES: conditioning, strength
         */
        inputs?: {
            conditioning: unknown;
            strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ConditioningSetMask {
        /**
         * INPUT_TYPES: conditioning, mask, strength, set_cond_area
         */
        inputs?: {
            conditioning: unknown;
            mask: unknown;
            strength: number;
            set_cond_area: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface KSamplerAdvanced {
        /**
         * INPUT_TYPES: model, add_noise, noise_seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, start_at_step, end_at_step, return_with_leftover_noise
         */
        inputs?: {
            model: unknown;
            add_noise: string;
            noise_seed: number;
            steps: number;
            cfg: number;
            sampler_name: string;
            scheduler: string;
            positive: unknown;
            negative: unknown;
            latent_image: unknown;
            start_at_step: number;
            end_at_step: number;
            return_with_leftover_noise: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SetLatentNoiseMask {
        /**
         * INPUT_TYPES: samples, mask
         */
        inputs?: {
            samples: unknown;
            mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentComposite {
        /**
         * INPUT_TYPES: samples_to, samples_from, x, y, feather
         */
        inputs?: {
            samples_to: unknown;
            samples_from: unknown;
            x: number;
            y: number;
            feather: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentBlend {
        /**
         * INPUT_TYPES: samples1, samples2, blend_factor
         */
        inputs?: {
            samples1: unknown;
            samples2: unknown;
            blend_factor: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentRotate {
        /**
         * INPUT_TYPES: samples, rotation
         */
        inputs?: {
            samples: unknown;
            rotation: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentFlip {
        /**
         * INPUT_TYPES: samples, flip_method
         */
        inputs?: {
            samples: unknown;
            flip_method: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentCrop {
        /**
         * INPUT_TYPES: samples, width, height, x, y
         */
        inputs?: {
            samples: unknown;
            width: number;
            height: number;
            x: number;
            y: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LoraLoader {
        /**
         * INPUT_TYPES: model, clip, lora_name, strength_model, strength_clip
         */
        inputs?: {
            model: unknown;
            clip: unknown;
            lora_name: string;
            strength_model: number;
            strength_clip: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface CLIPLoader {
        /**
         * INPUT_TYPES: clip_name, type
         */
        inputs?: {
            clip_name: string;
            type: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface UNETLoader {
        /**
         * INPUT_TYPES: unet_name, weight_dtype
         */
        inputs?: {
            unet_name: string;
            weight_dtype: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface DualCLIPLoader {
        /**
         * INPUT_TYPES: clip_name1, clip_name2, type
         */
        inputs?: {
            clip_name1: string;
            clip_name2: string;
            type: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPVisionEncode {
        /**
         * INPUT_TYPES: clip_vision, image, crop
         */
        inputs?: {
            clip_vision: unknown;
            image: unknown;
            crop: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP_VISION_OUTPUT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface StyleModelApply {
        /**
         * INPUT_TYPES: conditioning, style_model, clip_vision_output, strength, strength_type
         */
        inputs?: {
            conditioning: unknown;
            style_model: unknown;
            clip_vision_output: unknown;
            strength: number;
            strength_type: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface unCLIPConditioning {
        /**
         * INPUT_TYPES: conditioning, clip_vision_output, strength, noise_augmentation
         */
        inputs?: {
            conditioning: unknown;
            clip_vision_output: unknown;
            strength: number;
            noise_augmentation: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ControlNetApply {
        /**
         * INPUT_TYPES: conditioning, control_net, image, strength
         */
        inputs?: {
            conditioning: unknown;
            control_net: unknown;
            image: unknown;
            strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ControlNetApplyAdvanced {
        /**
         * INPUT_TYPES: positive, negative, control_net, image, strength, start_percent, end_percent
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            control_net: unknown;
            image: unknown;
            strength: number;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ControlNetLoader {
        /**
         * INPUT_TYPES: control_net_name
         */
        inputs?: {
            control_net_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface DiffControlNetLoader {
        /**
         * INPUT_TYPES: model, control_net_name
         */
        inputs?: {
            model: unknown;
            control_net_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface StyleModelLoader {
        /**
         * INPUT_TYPES: style_model_name
         */
        inputs?: {
            style_model_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STYLE_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPVisionLoader {
        /**
         * INPUT_TYPES: clip_name
         */
        inputs?: {
            clip_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP_VISION
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface VAEDecodeTiled {
        /**
         * INPUT_TYPES: samples, vae, tile_size, overlap, temporal_size, temporal_overlap
         */
        inputs?: {
            samples: unknown;
            vae: unknown;
            tile_size: number;
            overlap: number;
            temporal_size: number;
            temporal_overlap: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface VAEEncodeTiled {
        /**
         * INPUT_TYPES: pixels, vae, tile_size, overlap, temporal_size, temporal_overlap
         */
        inputs?: {
            pixels: unknown;
            vae: unknown;
            tile_size: number;
            overlap: number;
            temporal_size: number;
            temporal_overlap: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface unCLIPCheckpointLoader {
        /**
         * INPUT_TYPES: ckpt_name
         */
        inputs?: {
            ckpt_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, VAE, CLIP_VISION
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface GLIGENLoader {
        /**
         * INPUT_TYPES: gligen_name
         */
        inputs?: {
            gligen_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: GLIGEN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface GLIGENTextBoxApply {
        /**
         * INPUT_TYPES: conditioning_to, clip, gligen_textbox_model, text, width, height, x, y
         */
        inputs?: {
            conditioning_to: unknown;
            clip: unknown;
            gligen_textbox_model: unknown;
            text: string;
            width: number;
            height: number;
            x: number;
            y: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface InpaintModelConditioning {
        /**
         * INPUT_TYPES: positive, negative, vae, pixels, mask, noise_mask
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            vae: unknown;
            pixels: unknown;
            mask: unknown;
            noise_mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface CheckpointLoader {
        /**
         * INPUT_TYPES: config_name, ckpt_name
         */
        inputs?: {
            config_name: string;
            ckpt_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, VAE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface DiffusersLoader {
        /**
         * INPUT_TYPES: model_path
         */
        inputs?: {
            model_path: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, VAE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LoadLatent {
        /**
         * INPUT_TYPES: latent
         */
        inputs?: {
            latent: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SaveLatent {
        /**
         * INPUT_TYPES: samples, filename_prefix
         */
        inputs?: {
            samples: unknown;
            filename_prefix: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface ConditioningZeroOut {
        /**
         * INPUT_TYPES: conditioning
         */
        inputs?: {
            conditioning: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ConditioningSetTimestepRange {
        /**
         * INPUT_TYPES: conditioning, start, end
         */
        inputs?: {
            conditioning: unknown;
            start: number;
            end: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LoraLoaderModelOnly {
        /**
         * INPUT_TYPES: model, lora_name, strength_model
         */
        inputs?: {
            model: unknown;
            lora_name: string;
            strength_model: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentAdd {
        /**
         * INPUT_TYPES: samples1, samples2
         */
        inputs?: {
            samples1: unknown;
            samples2: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentSubtract {
        /**
         * INPUT_TYPES: samples1, samples2
         */
        inputs?: {
            samples1: unknown;
            samples2: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentMultiply {
        /**
         * INPUT_TYPES: samples, multiplier
         */
        inputs?: {
            samples: unknown;
            multiplier: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentInterpolate {
        /**
         * INPUT_TYPES: samples1, samples2, ratio
         */
        inputs?: {
            samples1: unknown;
            samples2: unknown;
            ratio: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentConcat {
        /**
         * INPUT_TYPES: samples1, samples2, dim
         */
        inputs?: {
            samples1: unknown;
            samples2: unknown;
            dim: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentCut {
        /**
         * INPUT_TYPES: samples, dim, index, amount
         */
        inputs?: {
            samples: unknown;
            dim: string;
            index: number;
            amount: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentBatch {
        /**
         * INPUT_TYPES: samples1, samples2
         */
        inputs?: {
            samples1: unknown;
            samples2: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentBatchSeedBehavior {
        /**
         * INPUT_TYPES: samples, seed_behavior
         */
        inputs?: {
            samples: unknown;
            seed_behavior: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentApplyOperation {
        /**
         * INPUT_TYPES: samples, operation
         */
        inputs?: {
            samples: unknown;
            operation: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentApplyOperationCFG {
        /**
         * INPUT_TYPES: model, operation
         */
        inputs?: {
            model: unknown;
            operation: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentOperationTonemapReinhard {
        /**
         * INPUT_TYPES: multiplier
         */
        inputs?: {
            multiplier: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT_OPERATION
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentOperationSharpen {
        /**
         * INPUT_TYPES: sharpen_radius, sigma, alpha
         */
        inputs?: {
            sharpen_radius: number;
            sigma: number;
            alpha: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT_OPERATION
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface HypernetworkLoader {
        /**
         * INPUT_TYPES: model, hypernetwork_name, strength
         */
        inputs?: {
            model: unknown;
            hypernetwork_name: string;
            strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface UpscaleModelLoader {
        /**
         * INPUT_TYPES: model_name
         */
        inputs?: {
            model_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: UPSCALE_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageUpscaleWithModel {
        /**
         * INPUT_TYPES: upscale_model, image
         */
        inputs?: {
            upscale_model: unknown;
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageBlend {
        /**
         * INPUT_TYPES: image1, image2, blend_factor, blend_mode
         */
        inputs?: {
            image1: unknown;
            image2: unknown;
            blend_factor: number;
            blend_mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageBlur {
        /**
         * INPUT_TYPES: image, blur_radius, sigma
         */
        inputs?: {
            image: unknown;
            blur_radius: number;
            sigma: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageQuantize {
        /**
         * INPUT_TYPES: image, colors, dither
         */
        inputs?: {
            image: unknown;
            colors: number;
            dither: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageSharpen {
        /**
         * INPUT_TYPES: image, sharpen_radius, sigma, alpha
         */
        inputs?: {
            image: unknown;
            sharpen_radius: number;
            sigma: number;
            alpha: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageScaleToTotalPixels {
        /**
         * INPUT_TYPES: image, upscale_method, megapixels
         */
        inputs?: {
            image: unknown;
            upscale_method: string;
            megapixels: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentCompositeMasked {
        /**
         * INPUT_TYPES: destination, source, x, y, resize_source
         */
        inputs?: {
            destination: unknown;
            source: unknown;
            x: number;
            y: number;
            resize_source: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageCompositeMasked {
        /**
         * INPUT_TYPES: destination, source, x, y, resize_source
         */
        inputs?: {
            destination: unknown;
            source: unknown;
            x: number;
            y: number;
            resize_source: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MaskToImage {
        /**
         * INPUT_TYPES: mask
         */
        inputs?: {
            mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageToMask {
        /**
         * INPUT_TYPES: image, channel
         */
        inputs?: {
            image: unknown;
            channel: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageColorToMask {
        /**
         * INPUT_TYPES: image, color
         */
        inputs?: {
            image: unknown;
            color: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SolidMask {
        /**
         * INPUT_TYPES: value, width, height
         */
        inputs?: {
            value: number;
            width: number;
            height: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface InvertMask {
        /**
         * INPUT_TYPES: mask
         */
        inputs?: {
            mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CropMask {
        /**
         * INPUT_TYPES: mask, x, y, width, height
         */
        inputs?: {
            mask: unknown;
            x: number;
            y: number;
            width: number;
            height: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MaskComposite {
        /**
         * INPUT_TYPES: destination, source, x, y, operation
         */
        inputs?: {
            destination: unknown;
            source: unknown;
            x: number;
            y: number;
            operation: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface FeatherMask {
        /**
         * INPUT_TYPES: mask, left, top, right, bottom
         */
        inputs?: {
            mask: unknown;
            left: number;
            top: number;
            right: number;
            bottom: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface GrowMask {
        /**
         * INPUT_TYPES: mask, expand, tapered_corners
         */
        inputs?: {
            mask: unknown;
            expand: number;
            tapered_corners: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ThresholdMask {
        /**
         * INPUT_TYPES: mask, value
         */
        inputs?: {
            mask: unknown;
            value: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MaskPreview {
        /**
         * INPUT_TYPES: mask
         */
        inputs?: {
            mask: unknown;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface PorterDuffImageComposite {
        /**
         * INPUT_TYPES: source, source_alpha, destination, destination_alpha, mode
         */
        inputs?: {
            source: unknown;
            source_alpha: unknown;
            destination: unknown;
            destination_alpha: unknown;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface SplitImageWithAlpha {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface JoinImageWithAlpha {
        /**
         * INPUT_TYPES: image, alpha
         */
        inputs?: {
            image: unknown;
            alpha: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface RebatchLatents {
        /**
         * INPUT_TYPES: latents, batch_size
         */
        inputs?: {
            latents: unknown;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface RebatchImages {
        /**
         * INPUT_TYPES: images, batch_size
         */
        inputs?: {
            images: unknown;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeSimple {
        /**
         * INPUT_TYPES: model1, model2, ratio
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            ratio: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeBlocks {
        /**
         * INPUT_TYPES: model1, model2, input, middle, out
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            input: number;
            middle: number;
            out: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeSubtract {
        /**
         * INPUT_TYPES: model1, model2, multiplier
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            multiplier: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeAdd {
        /**
         * INPUT_TYPES: model1, model2
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CheckpointSave {
        /**
         * INPUT_TYPES: model, clip, vae, filename_prefix
         */
        inputs?: {
            model: unknown;
            clip: unknown;
            vae: unknown;
            filename_prefix: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface CLIPMergeSimple {
        /**
         * INPUT_TYPES: clip1, clip2, ratio
         */
        inputs?: {
            clip1: unknown;
            clip2: unknown;
            ratio: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPMergeSubtract {
        /**
         * INPUT_TYPES: clip1, clip2, multiplier
         */
        inputs?: {
            clip1: unknown;
            clip2: unknown;
            multiplier: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPMergeAdd {
        /**
         * INPUT_TYPES: clip1, clip2
         */
        inputs?: {
            clip1: unknown;
            clip2: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPSave {
        /**
         * INPUT_TYPES: clip, filename_prefix
         */
        inputs?: {
            clip: unknown;
            filename_prefix: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface VAESave {
        /**
         * INPUT_TYPES: vae, filename_prefix
         */
        inputs?: {
            vae: unknown;
            filename_prefix: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface ModelSave {
        /**
         * INPUT_TYPES: model, filename_prefix
         */
        inputs?: {
            model: unknown;
            filename_prefix: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface TomePatchModel {
        /**
         * INPUT_TYPES: model, ratio
         */
        inputs?: {
            model: unknown;
            ratio: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPTextEncodeSDXLRefiner {
        /**
         * INPUT_TYPES: ascore, width, height, text, clip
         */
        inputs?: {
            ascore: number;
            width: number;
            height: number;
            text: string;
            clip: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPTextEncodeSDXL {
        /**
         * INPUT_TYPES: clip, width, height, crop_w, crop_h, target_width, target_height, text_g, text_l
         */
        inputs?: {
            clip: unknown;
            width: number;
            height: number;
            crop_w: number;
            crop_h: number;
            target_width: number;
            target_height: number;
            text_g: string;
            text_l: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Canny {
        /**
         * INPUT_TYPES: image, low_threshold, high_threshold
         */
        inputs?: {
            image: unknown;
            low_threshold: number;
            high_threshold: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface FreeU {
        /**
         * INPUT_TYPES: model, b1, b2, s1, s2
         */
        inputs?: {
            model: unknown;
            b1: number;
            b2: number;
            s1: number;
            s2: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface FreeU_V2 {
        /**
         * INPUT_TYPES: model, b1, b2, s1, s2
         */
        inputs?: {
            model: unknown;
            b1: number;
            b2: number;
            s1: number;
            s2: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SamplerCustom {
        /**
         * INPUT_TYPES: model, add_noise, noise_seed, cfg, positive, negative, sampler, sigmas, latent_image
         */
        inputs?: {
            model: unknown;
            add_noise: unknown;
            noise_seed: number;
            cfg: number;
            positive: unknown;
            negative: unknown;
            sampler: unknown;
            sigmas: unknown;
            latent_image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT, LATENT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface BasicScheduler {
        /**
         * INPUT_TYPES: model, scheduler, steps, denoise
         */
        inputs?: {
            model: unknown;
            scheduler: string;
            steps: number;
            denoise: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface KarrasScheduler {
        /**
         * INPUT_TYPES: steps, sigma_max, sigma_min, rho
         */
        inputs?: {
            steps: number;
            sigma_max: number;
            sigma_min: number;
            rho: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ExponentialScheduler {
        /**
         * INPUT_TYPES: steps, sigma_max, sigma_min
         */
        inputs?: {
            steps: number;
            sigma_max: number;
            sigma_min: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PolyexponentialScheduler {
        /**
         * INPUT_TYPES: steps, sigma_max, sigma_min, rho
         */
        inputs?: {
            steps: number;
            sigma_max: number;
            sigma_min: number;
            rho: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LaplaceScheduler {
        /**
         * INPUT_TYPES: steps, sigma_max, sigma_min, mu, beta
         */
        inputs?: {
            steps: number;
            sigma_max: number;
            sigma_min: number;
            mu: number;
            beta: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface VPScheduler {
        /**
         * INPUT_TYPES: steps, beta_d, beta_min, eps_s
         */
        inputs?: {
            steps: number;
            beta_d: number;
            beta_min: number;
            eps_s: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface BetaSamplingScheduler {
        /**
         * INPUT_TYPES: model, steps, alpha, beta
         */
        inputs?: {
            model: unknown;
            steps: number;
            alpha: number;
            beta: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SDTurboScheduler {
        /**
         * INPUT_TYPES: model, steps, denoise
         */
        inputs?: {
            model: unknown;
            steps: number;
            denoise: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface KSamplerSelect {
        /**
         * INPUT_TYPES: sampler_name
         */
        inputs?: {
            sampler_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAMPLER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SamplerEulerAncestral {
        /**
         * INPUT_TYPES: eta, s_noise
         */
        inputs?: {
            eta: number;
            s_noise: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAMPLER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SamplerEulerAncestralCFGPP {
        /**
         * INPUT_TYPES: eta, s_noise
         */
        inputs?: {
            eta: number;
            s_noise: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAMPLER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SamplerLMS {
        /**
         * INPUT_TYPES: order
         */
        inputs?: {
            order: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAMPLER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SamplerDPMPP_3M_SDE {
        /**
         * INPUT_TYPES: eta, s_noise, noise_device
         */
        inputs?: {
            eta: number;
            s_noise: number;
            noise_device: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAMPLER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SamplerDPMPP_2M_SDE {
        /**
         * INPUT_TYPES: solver_type, eta, s_noise, noise_device
         */
        inputs?: {
            solver_type: string;
            eta: number;
            s_noise: number;
            noise_device: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAMPLER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SamplerDPMPP_SDE {
        /**
         * INPUT_TYPES: eta, s_noise, r, noise_device
         */
        inputs?: {
            eta: number;
            s_noise: number;
            r: number;
            noise_device: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAMPLER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SamplerDPMPP_2S_Ancestral {
        /**
         * INPUT_TYPES: eta, s_noise
         */
        inputs?: {
            eta: number;
            s_noise: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAMPLER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SamplerDPMAdaptative {
        /**
         * INPUT_TYPES: order, rtol, atol, h_init, pcoeff, icoeff, dcoeff, accept_safety, eta, s_noise
         */
        inputs?: {
            order: number;
            rtol: number;
            atol: number;
            h_init: number;
            pcoeff: number;
            icoeff: number;
            dcoeff: number;
            accept_safety: number;
            eta: number;
            s_noise: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAMPLER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SamplerER_SDE {
        /**
         * INPUT_TYPES: solver_type, max_stage, eta, s_noise
         */
        inputs?: {
            solver_type: string;
            max_stage: number;
            eta: number;
            s_noise: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAMPLER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SamplerSASolver {
        /**
         * INPUT_TYPES: model, eta, sde_start_percent, sde_end_percent, s_noise, predictor_order, corrector_order, use_pece, simple_order_2
         */
        inputs?: {
            model: string;
            eta: number;
            sde_start_percent: number;
            sde_end_percent: number;
            s_noise: number;
            predictor_order: number;
            corrector_order: number;
            use_pece: string;
            simple_order_2: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAMPLER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SplitSigmas {
        /**
         * INPUT_TYPES: sigmas, step
         */
        inputs?: {
            sigmas: unknown;
            step: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS, SIGMAS
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface SplitSigmasDenoise {
        /**
         * INPUT_TYPES: sigmas, denoise
         */
        inputs?: {
            sigmas: unknown;
            denoise: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS, SIGMAS
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface FlipSigmas {
        /**
         * INPUT_TYPES: sigmas
         */
        inputs?: {
            sigmas: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SetFirstSigma {
        /**
         * INPUT_TYPES: sigmas, sigma
         */
        inputs?: {
            sigmas: unknown;
            sigma: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ExtendIntermediateSigmas {
        /**
         * INPUT_TYPES: sigmas, steps, start_at_sigma, end_at_sigma, spacing
         */
        inputs?: {
            sigmas: unknown;
            steps: number;
            start_at_sigma: number;
            end_at_sigma: number;
            spacing: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SamplingPercentToSigma {
        /**
         * INPUT_TYPES: model, sampling_percent, return_actual_sigma
         */
        inputs?: {
            model: string;
            sampling_percent: number;
            return_actual_sigma: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CFGGuider {
        /**
         * INPUT_TYPES: model, positive, negative, cfg
         */
        inputs?: {
            model: unknown;
            positive: unknown;
            negative: unknown;
            cfg: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: GUIDER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface DualCFGGuider {
        /**
         * INPUT_TYPES: model, cond1, cond2, negative, cfg_conds, cfg_cond2_negative, style
         */
        inputs?: {
            model: unknown;
            cond1: unknown;
            cond2: unknown;
            negative: unknown;
            cfg_conds: number;
            cfg_cond2_negative: number;
            style: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: GUIDER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface BasicGuider {
        /**
         * INPUT_TYPES: model, conditioning
         */
        inputs?: {
            model: unknown;
            conditioning: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: GUIDER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface RandomNoise {
        /**
         * INPUT_TYPES: noise_seed
         */
        inputs?: {
            noise_seed: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NOISE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface DisableNoise {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NOISE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface AddNoise {
        /**
         * INPUT_TYPES: model, noise, sigmas, latent_image
         */
        inputs?: {
            model: unknown;
            noise: unknown;
            sigmas: unknown;
            latent_image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SamplerCustomAdvanced {
        /**
         * INPUT_TYPES: noise, guider, sampler, sigmas, latent_image
         */
        inputs?: {
            noise: unknown;
            guider: unknown;
            sampler: unknown;
            sigmas: unknown;
            latent_image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT, LATENT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface HyperTile {
        /**
         * INPUT_TYPES: model, tile_size, swap_size, max_depth, scale_depth
         */
        inputs?: {
            model: unknown;
            tile_size: number;
            swap_size: number;
            max_depth: number;
            scale_depth: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelSamplingDiscrete {
        /**
         * INPUT_TYPES: model, sampling, zsnr
         */
        inputs?: {
            model: unknown;
            sampling: string;
            zsnr: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelSamplingContinuousEDM {
        /**
         * INPUT_TYPES: model, sampling, sigma_max, sigma_min
         */
        inputs?: {
            model: unknown;
            sampling: string;
            sigma_max: number;
            sigma_min: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelSamplingContinuousV {
        /**
         * INPUT_TYPES: model, sampling, sigma_max, sigma_min
         */
        inputs?: {
            model: unknown;
            sampling: string;
            sigma_max: number;
            sigma_min: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelSamplingStableCascade {
        /**
         * INPUT_TYPES: model, shift
         */
        inputs?: {
            model: unknown;
            shift: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelSamplingSD3 {
        /**
         * INPUT_TYPES: model, shift
         */
        inputs?: {
            model: unknown;
            shift: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelSamplingAuraFlow {
        /**
         * INPUT_TYPES: model, shift
         */
        inputs?: {
            model: unknown;
            shift: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelSamplingFlux {
        /**
         * INPUT_TYPES: model, max_shift, base_shift, width, height
         */
        inputs?: {
            model: unknown;
            max_shift: number;
            base_shift: number;
            width: number;
            height: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface RescaleCFG {
        /**
         * INPUT_TYPES: model, multiplier
         */
        inputs?: {
            model: unknown;
            multiplier: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelComputeDtype {
        /**
         * INPUT_TYPES: model, dtype
         */
        inputs?: {
            model: unknown;
            dtype: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PatchModelAddDownscale {
        /**
         * INPUT_TYPES: model, block_number, downscale_factor, start_percent, end_percent, downscale_after_skip, downscale_method, upscale_method
         */
        inputs?: {
            model: unknown;
            block_number: number;
            downscale_factor: number;
            start_percent: number;
            end_percent: number;
            downscale_after_skip: unknown;
            downscale_method: string;
            upscale_method: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageOnlyCheckpointLoader {
        /**
         * INPUT_TYPES: ckpt_name
         */
        inputs?: {
            ckpt_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP_VISION, VAE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface SVD_img2vid_Conditioning {
        /**
         * INPUT_TYPES: clip_vision, init_image, vae, width, height, video_frames, motion_bucket_id, fps, augmentation_level
         */
        inputs?: {
            clip_vision: unknown;
            init_image: unknown;
            vae: unknown;
            width: number;
            height: number;
            video_frames: number;
            motion_bucket_id: number;
            fps: number;
            augmentation_level: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface VideoLinearCFGGuidance {
        /**
         * INPUT_TYPES: model, min_cfg
         */
        inputs?: {
            model: unknown;
            min_cfg: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface VideoTriangleCFGGuidance {
        /**
         * INPUT_TYPES: model, min_cfg
         */
        inputs?: {
            model: unknown;
            min_cfg: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageOnlyCheckpointSave {
        /**
         * INPUT_TYPES: model, clip_vision, vae, filename_prefix
         */
        inputs?: {
            model: unknown;
            clip_vision: unknown;
            vae: unknown;
            filename_prefix: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface ConditioningSetAreaPercentageVideo {
        /**
         * INPUT_TYPES: conditioning, width, height, temporal, x, y, z, strength
         */
        inputs?: {
            conditioning: unknown;
            width: number;
            height: number;
            temporal: number;
            x: number;
            y: number;
            z: number;
            strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface TrainLoraNode {
        /**
         * INPUT_TYPES: model, latents, positive, batch_size, grad_accumulation_steps, steps, learning_rate, rank, optimizer, loss_function, seed, training_dtype, lora_dtype, algorithm, gradient_checkpointing, existing_lora
         */
        inputs?: {
            model: string;
            latents: unknown;
            positive: string;
            batch_size: number;
            grad_accumulation_steps: number;
            steps: number;
            learning_rate: number;
            rank: number;
            optimizer: string;
            loss_function: string;
            seed: number;
            training_dtype: string;
            lora_dtype: string;
            algorithm: string;
            gradient_checkpointing: string;
            existing_lora: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, LORA_MODEL, LOSS_MAP, INT
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface SaveLoRANode {
        /**
         * INPUT_TYPES: lora, prefix
         */
        inputs?: {
            lora: string;
            prefix: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface LoraModelLoader {
        /**
         * INPUT_TYPES: model, lora, strength_model
         */
        inputs?: {
            model: unknown;
            lora: string;
            strength_model: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LoadImageSetFromFolderNode {
        /**
         * INPUT_TYPES: folder
         */
        inputs?: {
            folder: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LoadImageTextSetFromFolderNode {
        /**
         * INPUT_TYPES: folder, clip
         */
        inputs?: {
            folder: string;
            clip: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LossGraphNode {
        /**
         * INPUT_TYPES: loss, filename_prefix
         */
        inputs?: {
            loss: string;
            filename_prefix: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface SelfAttentionGuidance {
        /**
         * INPUT_TYPES: model, scale, blur_sigma
         */
        inputs?: {
            model: unknown;
            scale: number;
            blur_sigma: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PerpNeg {
        /**
         * INPUT_TYPES: model, empty_conditioning, neg_scale
         */
        inputs?: {
            model: unknown;
            empty_conditioning: unknown;
            neg_scale: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PerpNegGuider {
        /**
         * INPUT_TYPES: model, positive, negative, empty_conditioning, cfg, neg_scale
         */
        inputs?: {
            model: unknown;
            positive: unknown;
            negative: unknown;
            empty_conditioning: unknown;
            cfg: number;
            neg_scale: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: GUIDER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface StableZero123_Conditioning {
        /**
         * INPUT_TYPES: clip_vision, init_image, vae, width, height, batch_size, elevation, azimuth
         */
        inputs?: {
            clip_vision: unknown;
            init_image: unknown;
            vae: unknown;
            width: number;
            height: number;
            batch_size: number;
            elevation: number;
            azimuth: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface StableZero123_Conditioning_Batched {
        /**
         * INPUT_TYPES: clip_vision, init_image, vae, width, height, batch_size, elevation, azimuth, elevation_batch_increment, azimuth_batch_increment
         */
        inputs?: {
            clip_vision: unknown;
            init_image: unknown;
            vae: unknown;
            width: number;
            height: number;
            batch_size: number;
            elevation: number;
            azimuth: number;
            elevation_batch_increment: number;
            azimuth_batch_increment: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface SV3D_Conditioning {
        /**
         * INPUT_TYPES: clip_vision, init_image, vae, width, height, video_frames, elevation
         */
        inputs?: {
            clip_vision: unknown;
            init_image: unknown;
            vae: unknown;
            width: number;
            height: number;
            video_frames: number;
            elevation: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface SD_4XUpscale_Conditioning {
        /**
         * INPUT_TYPES: images, positive, negative, scale_ratio, noise_augmentation
         */
        inputs?: {
            images: unknown;
            positive: unknown;
            negative: unknown;
            scale_ratio: number;
            noise_augmentation: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface PhotoMakerLoader {
        /**
         * INPUT_TYPES: photomaker_model_name
         */
        inputs?: {
            photomaker_model_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: PHOTOMAKER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PhotoMakerEncode {
        /**
         * INPUT_TYPES: photomaker, image, clip, text
         */
        inputs?: {
            photomaker: unknown;
            image: unknown;
            clip: unknown;
            text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPTextEncodePixArtAlpha {
        /**
         * INPUT_TYPES: width, height, text, clip
         */
        inputs?: {
            width: number;
            height: number;
            text: string;
            clip: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPTextEncodeControlnet {
        /**
         * INPUT_TYPES: clip, conditioning, text
         */
        inputs?: {
            clip: unknown;
            conditioning: unknown;
            text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface T5TokenizerOptions {
        /**
         * INPUT_TYPES: clip, min_padding, min_length
         */
        inputs?: {
            clip: unknown;
            min_padding: number;
            min_length: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Morphology {
        /**
         * INPUT_TYPES: image, operation, kernel_size
         */
        inputs?: {
            image: unknown;
            operation: string;
            kernel_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageRGBToYUV {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE, IMAGE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface ImageYUVToRGB {
        /**
         * INPUT_TYPES: Y, U, V
         */
        inputs?: {
            Y: unknown;
            U: unknown;
            V: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface StableCascade_EmptyLatentImage {
        /**
         * INPUT_TYPES: width, height, compression, batch_size
         */
        inputs?: {
            width: number;
            height: number;
            compression: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT, LATENT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface StableCascade_StageB_Conditioning {
        /**
         * INPUT_TYPES: conditioning, stage_c
         */
        inputs?: {
            conditioning: unknown;
            stage_c: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface StableCascade_StageC_VAEEncode {
        /**
         * INPUT_TYPES: image, vae, compression
         */
        inputs?: {
            image: unknown;
            vae: unknown;
            compression: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT, LATENT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface StableCascade_SuperResolutionControlnet {
        /**
         * INPUT_TYPES: image, vae
         */
        inputs?: {
            image: unknown;
            vae: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, LATENT, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface DifferentialDiffusion {
        /**
         * INPUT_TYPES: model
         */
        inputs?: {
            model: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface InstructPixToPixConditioning {
        /**
         * INPUT_TYPES: positive, negative, vae, pixels
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            vae: unknown;
            pixels: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface ModelMergeSD1 {
        /**
         * INPUT_TYPES: model1, model2, time_embed., label_emb., input_blocks.0., input_blocks.1., input_blocks.2., input_blocks.3., input_blocks.4., input_blocks.5., input_blocks.6., input_blocks.7., input_blocks.8., input_blocks.9., input_blocks.10., input_blocks.11., middle_block.0., middle_block.1., middle_block.2., output_blocks.0., output_blocks.1., output_blocks.2., output_blocks.3., output_blocks.4., output_blocks.5., output_blocks.6., output_blocks.7., output_blocks.8., output_blocks.9., output_blocks.10., output_blocks.11., out.
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            ["time_embed."]: number;
            ["label_emb."]: number;
            ["input_blocks.0."]: number;
            ["input_blocks.1."]: number;
            ["input_blocks.2."]: number;
            ["input_blocks.3."]: number;
            ["input_blocks.4."]: number;
            ["input_blocks.5."]: number;
            ["input_blocks.6."]: number;
            ["input_blocks.7."]: number;
            ["input_blocks.8."]: number;
            ["input_blocks.9."]: number;
            ["input_blocks.10."]: number;
            ["input_blocks.11."]: number;
            ["middle_block.0."]: number;
            ["middle_block.1."]: number;
            ["middle_block.2."]: number;
            ["output_blocks.0."]: number;
            ["output_blocks.1."]: number;
            ["output_blocks.2."]: number;
            ["output_blocks.3."]: number;
            ["output_blocks.4."]: number;
            ["output_blocks.5."]: number;
            ["output_blocks.6."]: number;
            ["output_blocks.7."]: number;
            ["output_blocks.8."]: number;
            ["output_blocks.9."]: number;
            ["output_blocks.10."]: number;
            ["output_blocks.11."]: number;
            ["out."]: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeSD2 {
        /**
         * INPUT_TYPES: model1, model2, time_embed., label_emb., input_blocks.0., input_blocks.1., input_blocks.2., input_blocks.3., input_blocks.4., input_blocks.5., input_blocks.6., input_blocks.7., input_blocks.8., input_blocks.9., input_blocks.10., input_blocks.11., middle_block.0., middle_block.1., middle_block.2., output_blocks.0., output_blocks.1., output_blocks.2., output_blocks.3., output_blocks.4., output_blocks.5., output_blocks.6., output_blocks.7., output_blocks.8., output_blocks.9., output_blocks.10., output_blocks.11., out.
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            ["time_embed."]: number;
            ["label_emb."]: number;
            ["input_blocks.0."]: number;
            ["input_blocks.1."]: number;
            ["input_blocks.2."]: number;
            ["input_blocks.3."]: number;
            ["input_blocks.4."]: number;
            ["input_blocks.5."]: number;
            ["input_blocks.6."]: number;
            ["input_blocks.7."]: number;
            ["input_blocks.8."]: number;
            ["input_blocks.9."]: number;
            ["input_blocks.10."]: number;
            ["input_blocks.11."]: number;
            ["middle_block.0."]: number;
            ["middle_block.1."]: number;
            ["middle_block.2."]: number;
            ["output_blocks.0."]: number;
            ["output_blocks.1."]: number;
            ["output_blocks.2."]: number;
            ["output_blocks.3."]: number;
            ["output_blocks.4."]: number;
            ["output_blocks.5."]: number;
            ["output_blocks.6."]: number;
            ["output_blocks.7."]: number;
            ["output_blocks.8."]: number;
            ["output_blocks.9."]: number;
            ["output_blocks.10."]: number;
            ["output_blocks.11."]: number;
            ["out."]: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeSDXL {
        /**
         * INPUT_TYPES: model1, model2, time_embed., label_emb., input_blocks.0, input_blocks.1, input_blocks.2, input_blocks.3, input_blocks.4, input_blocks.5, input_blocks.6, input_blocks.7, input_blocks.8, middle_block.0, middle_block.1, middle_block.2, output_blocks.0, output_blocks.1, output_blocks.2, output_blocks.3, output_blocks.4, output_blocks.5, output_blocks.6, output_blocks.7, output_blocks.8, out.
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            ["time_embed."]: number;
            ["label_emb."]: number;
            ["input_blocks.0"]: number;
            ["input_blocks.1"]: number;
            ["input_blocks.2"]: number;
            ["input_blocks.3"]: number;
            ["input_blocks.4"]: number;
            ["input_blocks.5"]: number;
            ["input_blocks.6"]: number;
            ["input_blocks.7"]: number;
            ["input_blocks.8"]: number;
            ["middle_block.0"]: number;
            ["middle_block.1"]: number;
            ["middle_block.2"]: number;
            ["output_blocks.0"]: number;
            ["output_blocks.1"]: number;
            ["output_blocks.2"]: number;
            ["output_blocks.3"]: number;
            ["output_blocks.4"]: number;
            ["output_blocks.5"]: number;
            ["output_blocks.6"]: number;
            ["output_blocks.7"]: number;
            ["output_blocks.8"]: number;
            ["out."]: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeSD3_2B {
        /**
         * INPUT_TYPES: model1, model2, pos_embed., x_embedder., context_embedder., y_embedder., t_embedder., joint_blocks.0., joint_blocks.1., joint_blocks.2., joint_blocks.3., joint_blocks.4., joint_blocks.5., joint_blocks.6., joint_blocks.7., joint_blocks.8., joint_blocks.9., joint_blocks.10., joint_blocks.11., joint_blocks.12., joint_blocks.13., joint_blocks.14., joint_blocks.15., joint_blocks.16., joint_blocks.17., joint_blocks.18., joint_blocks.19., joint_blocks.20., joint_blocks.21., joint_blocks.22., joint_blocks.23., final_layer.
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            ["pos_embed."]: number;
            ["x_embedder."]: number;
            ["context_embedder."]: number;
            ["y_embedder."]: number;
            ["t_embedder."]: number;
            ["joint_blocks.0."]: number;
            ["joint_blocks.1."]: number;
            ["joint_blocks.2."]: number;
            ["joint_blocks.3."]: number;
            ["joint_blocks.4."]: number;
            ["joint_blocks.5."]: number;
            ["joint_blocks.6."]: number;
            ["joint_blocks.7."]: number;
            ["joint_blocks.8."]: number;
            ["joint_blocks.9."]: number;
            ["joint_blocks.10."]: number;
            ["joint_blocks.11."]: number;
            ["joint_blocks.12."]: number;
            ["joint_blocks.13."]: number;
            ["joint_blocks.14."]: number;
            ["joint_blocks.15."]: number;
            ["joint_blocks.16."]: number;
            ["joint_blocks.17."]: number;
            ["joint_blocks.18."]: number;
            ["joint_blocks.19."]: number;
            ["joint_blocks.20."]: number;
            ["joint_blocks.21."]: number;
            ["joint_blocks.22."]: number;
            ["joint_blocks.23."]: number;
            ["final_layer."]: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeAuraflow {
        /**
         * INPUT_TYPES: model1, model2, init_x_linear., positional_encoding, cond_seq_linear., register_tokens, t_embedder., double_layers.0., double_layers.1., double_layers.2., double_layers.3., single_layers.0., single_layers.1., single_layers.2., single_layers.3., single_layers.4., single_layers.5., single_layers.6., single_layers.7., single_layers.8., single_layers.9., single_layers.10., single_layers.11., single_layers.12., single_layers.13., single_layers.14., single_layers.15., single_layers.16., single_layers.17., single_layers.18., single_layers.19., single_layers.20., single_layers.21., single_layers.22., single_layers.23., single_layers.24., single_layers.25., single_layers.26., single_layers.27., single_layers.28., single_layers.29., single_layers.30., single_layers.31., modF., final_linear.
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            ["init_x_linear."]: number;
            positional_encoding: number;
            ["cond_seq_linear."]: number;
            register_tokens: number;
            ["t_embedder."]: number;
            ["double_layers.0."]: number;
            ["double_layers.1."]: number;
            ["double_layers.2."]: number;
            ["double_layers.3."]: number;
            ["single_layers.0."]: number;
            ["single_layers.1."]: number;
            ["single_layers.2."]: number;
            ["single_layers.3."]: number;
            ["single_layers.4."]: number;
            ["single_layers.5."]: number;
            ["single_layers.6."]: number;
            ["single_layers.7."]: number;
            ["single_layers.8."]: number;
            ["single_layers.9."]: number;
            ["single_layers.10."]: number;
            ["single_layers.11."]: number;
            ["single_layers.12."]: number;
            ["single_layers.13."]: number;
            ["single_layers.14."]: number;
            ["single_layers.15."]: number;
            ["single_layers.16."]: number;
            ["single_layers.17."]: number;
            ["single_layers.18."]: number;
            ["single_layers.19."]: number;
            ["single_layers.20."]: number;
            ["single_layers.21."]: number;
            ["single_layers.22."]: number;
            ["single_layers.23."]: number;
            ["single_layers.24."]: number;
            ["single_layers.25."]: number;
            ["single_layers.26."]: number;
            ["single_layers.27."]: number;
            ["single_layers.28."]: number;
            ["single_layers.29."]: number;
            ["single_layers.30."]: number;
            ["single_layers.31."]: number;
            ["modF."]: number;
            ["final_linear."]: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeFlux1 {
        /**
         * INPUT_TYPES: model1, model2, img_in., time_in., guidance_in, vector_in., txt_in., double_blocks.0., double_blocks.1., double_blocks.2., double_blocks.3., double_blocks.4., double_blocks.5., double_blocks.6., double_blocks.7., double_blocks.8., double_blocks.9., double_blocks.10., double_blocks.11., double_blocks.12., double_blocks.13., double_blocks.14., double_blocks.15., double_blocks.16., double_blocks.17., double_blocks.18., single_blocks.0., single_blocks.1., single_blocks.2., single_blocks.3., single_blocks.4., single_blocks.5., single_blocks.6., single_blocks.7., single_blocks.8., single_blocks.9., single_blocks.10., single_blocks.11., single_blocks.12., single_blocks.13., single_blocks.14., single_blocks.15., single_blocks.16., single_blocks.17., single_blocks.18., single_blocks.19., single_blocks.20., single_blocks.21., single_blocks.22., single_blocks.23., single_blocks.24., single_blocks.25., single_blocks.26., single_blocks.27., single_blocks.28., single_blocks.29., single_blocks.30., single_blocks.31., single_blocks.32., single_blocks.33., single_blocks.34., single_blocks.35., single_blocks.36., single_blocks.37., final_layer.
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            ["img_in."]: number;
            ["time_in."]: number;
            guidance_in: number;
            ["vector_in."]: number;
            ["txt_in."]: number;
            ["double_blocks.0."]: number;
            ["double_blocks.1."]: number;
            ["double_blocks.2."]: number;
            ["double_blocks.3."]: number;
            ["double_blocks.4."]: number;
            ["double_blocks.5."]: number;
            ["double_blocks.6."]: number;
            ["double_blocks.7."]: number;
            ["double_blocks.8."]: number;
            ["double_blocks.9."]: number;
            ["double_blocks.10."]: number;
            ["double_blocks.11."]: number;
            ["double_blocks.12."]: number;
            ["double_blocks.13."]: number;
            ["double_blocks.14."]: number;
            ["double_blocks.15."]: number;
            ["double_blocks.16."]: number;
            ["double_blocks.17."]: number;
            ["double_blocks.18."]: number;
            ["single_blocks.0."]: number;
            ["single_blocks.1."]: number;
            ["single_blocks.2."]: number;
            ["single_blocks.3."]: number;
            ["single_blocks.4."]: number;
            ["single_blocks.5."]: number;
            ["single_blocks.6."]: number;
            ["single_blocks.7."]: number;
            ["single_blocks.8."]: number;
            ["single_blocks.9."]: number;
            ["single_blocks.10."]: number;
            ["single_blocks.11."]: number;
            ["single_blocks.12."]: number;
            ["single_blocks.13."]: number;
            ["single_blocks.14."]: number;
            ["single_blocks.15."]: number;
            ["single_blocks.16."]: number;
            ["single_blocks.17."]: number;
            ["single_blocks.18."]: number;
            ["single_blocks.19."]: number;
            ["single_blocks.20."]: number;
            ["single_blocks.21."]: number;
            ["single_blocks.22."]: number;
            ["single_blocks.23."]: number;
            ["single_blocks.24."]: number;
            ["single_blocks.25."]: number;
            ["single_blocks.26."]: number;
            ["single_blocks.27."]: number;
            ["single_blocks.28."]: number;
            ["single_blocks.29."]: number;
            ["single_blocks.30."]: number;
            ["single_blocks.31."]: number;
            ["single_blocks.32."]: number;
            ["single_blocks.33."]: number;
            ["single_blocks.34."]: number;
            ["single_blocks.35."]: number;
            ["single_blocks.36."]: number;
            ["single_blocks.37."]: number;
            ["final_layer."]: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeSD35_Large {
        /**
         * INPUT_TYPES: model1, model2, pos_embed., x_embedder., context_embedder., y_embedder., t_embedder., joint_blocks.0., joint_blocks.1., joint_blocks.2., joint_blocks.3., joint_blocks.4., joint_blocks.5., joint_blocks.6., joint_blocks.7., joint_blocks.8., joint_blocks.9., joint_blocks.10., joint_blocks.11., joint_blocks.12., joint_blocks.13., joint_blocks.14., joint_blocks.15., joint_blocks.16., joint_blocks.17., joint_blocks.18., joint_blocks.19., joint_blocks.20., joint_blocks.21., joint_blocks.22., joint_blocks.23., joint_blocks.24., joint_blocks.25., joint_blocks.26., joint_blocks.27., joint_blocks.28., joint_blocks.29., joint_blocks.30., joint_blocks.31., joint_blocks.32., joint_blocks.33., joint_blocks.34., joint_blocks.35., joint_blocks.36., joint_blocks.37., final_layer.
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            ["pos_embed."]: number;
            ["x_embedder."]: number;
            ["context_embedder."]: number;
            ["y_embedder."]: number;
            ["t_embedder."]: number;
            ["joint_blocks.0."]: number;
            ["joint_blocks.1."]: number;
            ["joint_blocks.2."]: number;
            ["joint_blocks.3."]: number;
            ["joint_blocks.4."]: number;
            ["joint_blocks.5."]: number;
            ["joint_blocks.6."]: number;
            ["joint_blocks.7."]: number;
            ["joint_blocks.8."]: number;
            ["joint_blocks.9."]: number;
            ["joint_blocks.10."]: number;
            ["joint_blocks.11."]: number;
            ["joint_blocks.12."]: number;
            ["joint_blocks.13."]: number;
            ["joint_blocks.14."]: number;
            ["joint_blocks.15."]: number;
            ["joint_blocks.16."]: number;
            ["joint_blocks.17."]: number;
            ["joint_blocks.18."]: number;
            ["joint_blocks.19."]: number;
            ["joint_blocks.20."]: number;
            ["joint_blocks.21."]: number;
            ["joint_blocks.22."]: number;
            ["joint_blocks.23."]: number;
            ["joint_blocks.24."]: number;
            ["joint_blocks.25."]: number;
            ["joint_blocks.26."]: number;
            ["joint_blocks.27."]: number;
            ["joint_blocks.28."]: number;
            ["joint_blocks.29."]: number;
            ["joint_blocks.30."]: number;
            ["joint_blocks.31."]: number;
            ["joint_blocks.32."]: number;
            ["joint_blocks.33."]: number;
            ["joint_blocks.34."]: number;
            ["joint_blocks.35."]: number;
            ["joint_blocks.36."]: number;
            ["joint_blocks.37."]: number;
            ["final_layer."]: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeMochiPreview {
        /**
         * INPUT_TYPES: model1, model2, pos_frequencies., t_embedder., t5_y_embedder., t5_yproj., blocks.0., blocks.1., blocks.2., blocks.3., blocks.4., blocks.5., blocks.6., blocks.7., blocks.8., blocks.9., blocks.10., blocks.11., blocks.12., blocks.13., blocks.14., blocks.15., blocks.16., blocks.17., blocks.18., blocks.19., blocks.20., blocks.21., blocks.22., blocks.23., blocks.24., blocks.25., blocks.26., blocks.27., blocks.28., blocks.29., blocks.30., blocks.31., blocks.32., blocks.33., blocks.34., blocks.35., blocks.36., blocks.37., blocks.38., blocks.39., blocks.40., blocks.41., blocks.42., blocks.43., blocks.44., blocks.45., blocks.46., blocks.47., final_layer.
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            ["pos_frequencies."]: number;
            ["t_embedder."]: number;
            ["t5_y_embedder."]: number;
            ["t5_yproj."]: number;
            ["blocks.0."]: number;
            ["blocks.1."]: number;
            ["blocks.2."]: number;
            ["blocks.3."]: number;
            ["blocks.4."]: number;
            ["blocks.5."]: number;
            ["blocks.6."]: number;
            ["blocks.7."]: number;
            ["blocks.8."]: number;
            ["blocks.9."]: number;
            ["blocks.10."]: number;
            ["blocks.11."]: number;
            ["blocks.12."]: number;
            ["blocks.13."]: number;
            ["blocks.14."]: number;
            ["blocks.15."]: number;
            ["blocks.16."]: number;
            ["blocks.17."]: number;
            ["blocks.18."]: number;
            ["blocks.19."]: number;
            ["blocks.20."]: number;
            ["blocks.21."]: number;
            ["blocks.22."]: number;
            ["blocks.23."]: number;
            ["blocks.24."]: number;
            ["blocks.25."]: number;
            ["blocks.26."]: number;
            ["blocks.27."]: number;
            ["blocks.28."]: number;
            ["blocks.29."]: number;
            ["blocks.30."]: number;
            ["blocks.31."]: number;
            ["blocks.32."]: number;
            ["blocks.33."]: number;
            ["blocks.34."]: number;
            ["blocks.35."]: number;
            ["blocks.36."]: number;
            ["blocks.37."]: number;
            ["blocks.38."]: number;
            ["blocks.39."]: number;
            ["blocks.40."]: number;
            ["blocks.41."]: number;
            ["blocks.42."]: number;
            ["blocks.43."]: number;
            ["blocks.44."]: number;
            ["blocks.45."]: number;
            ["blocks.46."]: number;
            ["blocks.47."]: number;
            ["final_layer."]: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeLTXV {
        /**
         * INPUT_TYPES: model1, model2, patchify_proj., adaln_single., caption_projection., transformer_blocks.0., transformer_blocks.1., transformer_blocks.2., transformer_blocks.3., transformer_blocks.4., transformer_blocks.5., transformer_blocks.6., transformer_blocks.7., transformer_blocks.8., transformer_blocks.9., transformer_blocks.10., transformer_blocks.11., transformer_blocks.12., transformer_blocks.13., transformer_blocks.14., transformer_blocks.15., transformer_blocks.16., transformer_blocks.17., transformer_blocks.18., transformer_blocks.19., transformer_blocks.20., transformer_blocks.21., transformer_blocks.22., transformer_blocks.23., transformer_blocks.24., transformer_blocks.25., transformer_blocks.26., transformer_blocks.27., scale_shift_table, proj_out.
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            ["patchify_proj."]: number;
            ["adaln_single."]: number;
            ["caption_projection."]: number;
            ["transformer_blocks.0."]: number;
            ["transformer_blocks.1."]: number;
            ["transformer_blocks.2."]: number;
            ["transformer_blocks.3."]: number;
            ["transformer_blocks.4."]: number;
            ["transformer_blocks.5."]: number;
            ["transformer_blocks.6."]: number;
            ["transformer_blocks.7."]: number;
            ["transformer_blocks.8."]: number;
            ["transformer_blocks.9."]: number;
            ["transformer_blocks.10."]: number;
            ["transformer_blocks.11."]: number;
            ["transformer_blocks.12."]: number;
            ["transformer_blocks.13."]: number;
            ["transformer_blocks.14."]: number;
            ["transformer_blocks.15."]: number;
            ["transformer_blocks.16."]: number;
            ["transformer_blocks.17."]: number;
            ["transformer_blocks.18."]: number;
            ["transformer_blocks.19."]: number;
            ["transformer_blocks.20."]: number;
            ["transformer_blocks.21."]: number;
            ["transformer_blocks.22."]: number;
            ["transformer_blocks.23."]: number;
            ["transformer_blocks.24."]: number;
            ["transformer_blocks.25."]: number;
            ["transformer_blocks.26."]: number;
            ["transformer_blocks.27."]: number;
            scale_shift_table: number;
            ["proj_out."]: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeCosmos7B {
        /**
         * INPUT_TYPES: model1, model2, pos_embedder., extra_pos_embedder., x_embedder., t_embedder., affline_norm., blocks.block0., blocks.block1., blocks.block2., blocks.block3., blocks.block4., blocks.block5., blocks.block6., blocks.block7., blocks.block8., blocks.block9., blocks.block10., blocks.block11., blocks.block12., blocks.block13., blocks.block14., blocks.block15., blocks.block16., blocks.block17., blocks.block18., blocks.block19., blocks.block20., blocks.block21., blocks.block22., blocks.block23., blocks.block24., blocks.block25., blocks.block26., blocks.block27., final_layer.
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            ["pos_embedder."]: number;
            ["extra_pos_embedder."]: number;
            ["x_embedder."]: number;
            ["t_embedder."]: number;
            ["affline_norm."]: number;
            ["blocks.block0."]: number;
            ["blocks.block1."]: number;
            ["blocks.block2."]: number;
            ["blocks.block3."]: number;
            ["blocks.block4."]: number;
            ["blocks.block5."]: number;
            ["blocks.block6."]: number;
            ["blocks.block7."]: number;
            ["blocks.block8."]: number;
            ["blocks.block9."]: number;
            ["blocks.block10."]: number;
            ["blocks.block11."]: number;
            ["blocks.block12."]: number;
            ["blocks.block13."]: number;
            ["blocks.block14."]: number;
            ["blocks.block15."]: number;
            ["blocks.block16."]: number;
            ["blocks.block17."]: number;
            ["blocks.block18."]: number;
            ["blocks.block19."]: number;
            ["blocks.block20."]: number;
            ["blocks.block21."]: number;
            ["blocks.block22."]: number;
            ["blocks.block23."]: number;
            ["blocks.block24."]: number;
            ["blocks.block25."]: number;
            ["blocks.block26."]: number;
            ["blocks.block27."]: number;
            ["final_layer."]: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeCosmos14B {
        /**
         * INPUT_TYPES: model1, model2, pos_embedder., extra_pos_embedder., x_embedder., t_embedder., affline_norm., blocks.block0., blocks.block1., blocks.block2., blocks.block3., blocks.block4., blocks.block5., blocks.block6., blocks.block7., blocks.block8., blocks.block9., blocks.block10., blocks.block11., blocks.block12., blocks.block13., blocks.block14., blocks.block15., blocks.block16., blocks.block17., blocks.block18., blocks.block19., blocks.block20., blocks.block21., blocks.block22., blocks.block23., blocks.block24., blocks.block25., blocks.block26., blocks.block27., blocks.block28., blocks.block29., blocks.block30., blocks.block31., blocks.block32., blocks.block33., blocks.block34., blocks.block35., final_layer.
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            ["pos_embedder."]: number;
            ["extra_pos_embedder."]: number;
            ["x_embedder."]: number;
            ["t_embedder."]: number;
            ["affline_norm."]: number;
            ["blocks.block0."]: number;
            ["blocks.block1."]: number;
            ["blocks.block2."]: number;
            ["blocks.block3."]: number;
            ["blocks.block4."]: number;
            ["blocks.block5."]: number;
            ["blocks.block6."]: number;
            ["blocks.block7."]: number;
            ["blocks.block8."]: number;
            ["blocks.block9."]: number;
            ["blocks.block10."]: number;
            ["blocks.block11."]: number;
            ["blocks.block12."]: number;
            ["blocks.block13."]: number;
            ["blocks.block14."]: number;
            ["blocks.block15."]: number;
            ["blocks.block16."]: number;
            ["blocks.block17."]: number;
            ["blocks.block18."]: number;
            ["blocks.block19."]: number;
            ["blocks.block20."]: number;
            ["blocks.block21."]: number;
            ["blocks.block22."]: number;
            ["blocks.block23."]: number;
            ["blocks.block24."]: number;
            ["blocks.block25."]: number;
            ["blocks.block26."]: number;
            ["blocks.block27."]: number;
            ["blocks.block28."]: number;
            ["blocks.block29."]: number;
            ["blocks.block30."]: number;
            ["blocks.block31."]: number;
            ["blocks.block32."]: number;
            ["blocks.block33."]: number;
            ["blocks.block34."]: number;
            ["blocks.block35."]: number;
            ["final_layer."]: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeWAN2_1 {
        /**
         * INPUT_TYPES: model1, model2, patch_embedding., time_embedding., time_projection., text_embedding., img_emb., blocks.0., blocks.1., blocks.2., blocks.3., blocks.4., blocks.5., blocks.6., blocks.7., blocks.8., blocks.9., blocks.10., blocks.11., blocks.12., blocks.13., blocks.14., blocks.15., blocks.16., blocks.17., blocks.18., blocks.19., blocks.20., blocks.21., blocks.22., blocks.23., blocks.24., blocks.25., blocks.26., blocks.27., blocks.28., blocks.29., blocks.30., blocks.31., blocks.32., blocks.33., blocks.34., blocks.35., blocks.36., blocks.37., blocks.38., blocks.39., head.
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            ["patch_embedding."]: number;
            ["time_embedding."]: number;
            ["time_projection."]: number;
            ["text_embedding."]: number;
            ["img_emb."]: number;
            ["blocks.0."]: number;
            ["blocks.1."]: number;
            ["blocks.2."]: number;
            ["blocks.3."]: number;
            ["blocks.4."]: number;
            ["blocks.5."]: number;
            ["blocks.6."]: number;
            ["blocks.7."]: number;
            ["blocks.8."]: number;
            ["blocks.9."]: number;
            ["blocks.10."]: number;
            ["blocks.11."]: number;
            ["blocks.12."]: number;
            ["blocks.13."]: number;
            ["blocks.14."]: number;
            ["blocks.15."]: number;
            ["blocks.16."]: number;
            ["blocks.17."]: number;
            ["blocks.18."]: number;
            ["blocks.19."]: number;
            ["blocks.20."]: number;
            ["blocks.21."]: number;
            ["blocks.22."]: number;
            ["blocks.23."]: number;
            ["blocks.24."]: number;
            ["blocks.25."]: number;
            ["blocks.26."]: number;
            ["blocks.27."]: number;
            ["blocks.28."]: number;
            ["blocks.29."]: number;
            ["blocks.30."]: number;
            ["blocks.31."]: number;
            ["blocks.32."]: number;
            ["blocks.33."]: number;
            ["blocks.34."]: number;
            ["blocks.35."]: number;
            ["blocks.36."]: number;
            ["blocks.37."]: number;
            ["blocks.38."]: number;
            ["blocks.39."]: number;
            ["head."]: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeCosmosPredict2_2B {
        /**
         * INPUT_TYPES: model1, model2, pos_embedder., x_embedder., t_embedder., t_embedding_norm., blocks.0., blocks.1., blocks.2., blocks.3., blocks.4., blocks.5., blocks.6., blocks.7., blocks.8., blocks.9., blocks.10., blocks.11., blocks.12., blocks.13., blocks.14., blocks.15., blocks.16., blocks.17., blocks.18., blocks.19., blocks.20., blocks.21., blocks.22., blocks.23., blocks.24., blocks.25., blocks.26., blocks.27., final_layer.
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            ["pos_embedder."]: number;
            ["x_embedder."]: number;
            ["t_embedder."]: number;
            ["t_embedding_norm."]: number;
            ["blocks.0."]: number;
            ["blocks.1."]: number;
            ["blocks.2."]: number;
            ["blocks.3."]: number;
            ["blocks.4."]: number;
            ["blocks.5."]: number;
            ["blocks.6."]: number;
            ["blocks.7."]: number;
            ["blocks.8."]: number;
            ["blocks.9."]: number;
            ["blocks.10."]: number;
            ["blocks.11."]: number;
            ["blocks.12."]: number;
            ["blocks.13."]: number;
            ["blocks.14."]: number;
            ["blocks.15."]: number;
            ["blocks.16."]: number;
            ["blocks.17."]: number;
            ["blocks.18."]: number;
            ["blocks.19."]: number;
            ["blocks.20."]: number;
            ["blocks.21."]: number;
            ["blocks.22."]: number;
            ["blocks.23."]: number;
            ["blocks.24."]: number;
            ["blocks.25."]: number;
            ["blocks.26."]: number;
            ["blocks.27."]: number;
            ["final_layer."]: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeCosmosPredict2_14B {
        /**
         * INPUT_TYPES: model1, model2, pos_embedder., x_embedder., t_embedder., t_embedding_norm., blocks.0., blocks.1., blocks.2., blocks.3., blocks.4., blocks.5., blocks.6., blocks.7., blocks.8., blocks.9., blocks.10., blocks.11., blocks.12., blocks.13., blocks.14., blocks.15., blocks.16., blocks.17., blocks.18., blocks.19., blocks.20., blocks.21., blocks.22., blocks.23., blocks.24., blocks.25., blocks.26., blocks.27., blocks.28., blocks.29., blocks.30., blocks.31., blocks.32., blocks.33., blocks.34., blocks.35., final_layer.
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            ["pos_embedder."]: number;
            ["x_embedder."]: number;
            ["t_embedder."]: number;
            ["t_embedding_norm."]: number;
            ["blocks.0."]: number;
            ["blocks.1."]: number;
            ["blocks.2."]: number;
            ["blocks.3."]: number;
            ["blocks.4."]: number;
            ["blocks.5."]: number;
            ["blocks.6."]: number;
            ["blocks.7."]: number;
            ["blocks.8."]: number;
            ["blocks.9."]: number;
            ["blocks.10."]: number;
            ["blocks.11."]: number;
            ["blocks.12."]: number;
            ["blocks.13."]: number;
            ["blocks.14."]: number;
            ["blocks.15."]: number;
            ["blocks.16."]: number;
            ["blocks.17."]: number;
            ["blocks.18."]: number;
            ["blocks.19."]: number;
            ["blocks.20."]: number;
            ["blocks.21."]: number;
            ["blocks.22."]: number;
            ["blocks.23."]: number;
            ["blocks.24."]: number;
            ["blocks.25."]: number;
            ["blocks.26."]: number;
            ["blocks.27."]: number;
            ["blocks.28."]: number;
            ["blocks.29."]: number;
            ["blocks.30."]: number;
            ["blocks.31."]: number;
            ["blocks.32."]: number;
            ["blocks.33."]: number;
            ["blocks.34."]: number;
            ["blocks.35."]: number;
            ["final_layer."]: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelMergeQwenImage {
        /**
         * INPUT_TYPES: model1, model2, pos_embeds., img_in., txt_norm., txt_in., time_text_embed., transformer_blocks.0., transformer_blocks.1., transformer_blocks.2., transformer_blocks.3., transformer_blocks.4., transformer_blocks.5., transformer_blocks.6., transformer_blocks.7., transformer_blocks.8., transformer_blocks.9., transformer_blocks.10., transformer_blocks.11., transformer_blocks.12., transformer_blocks.13., transformer_blocks.14., transformer_blocks.15., transformer_blocks.16., transformer_blocks.17., transformer_blocks.18., transformer_blocks.19., transformer_blocks.20., transformer_blocks.21., transformer_blocks.22., transformer_blocks.23., transformer_blocks.24., transformer_blocks.25., transformer_blocks.26., transformer_blocks.27., transformer_blocks.28., transformer_blocks.29., transformer_blocks.30., transformer_blocks.31., transformer_blocks.32., transformer_blocks.33., transformer_blocks.34., transformer_blocks.35., transformer_blocks.36., transformer_blocks.37., transformer_blocks.38., transformer_blocks.39., transformer_blocks.40., transformer_blocks.41., transformer_blocks.42., transformer_blocks.43., transformer_blocks.44., transformer_blocks.45., transformer_blocks.46., transformer_blocks.47., transformer_blocks.48., transformer_blocks.49., transformer_blocks.50., transformer_blocks.51., transformer_blocks.52., transformer_blocks.53., transformer_blocks.54., transformer_blocks.55., transformer_blocks.56., transformer_blocks.57., transformer_blocks.58., transformer_blocks.59., proj_out.
         */
        inputs?: {
            model1: unknown;
            model2: unknown;
            ["pos_embeds."]: number;
            ["img_in."]: number;
            ["txt_norm."]: number;
            ["txt_in."]: number;
            ["time_text_embed."]: number;
            ["transformer_blocks.0."]: number;
            ["transformer_blocks.1."]: number;
            ["transformer_blocks.2."]: number;
            ["transformer_blocks.3."]: number;
            ["transformer_blocks.4."]: number;
            ["transformer_blocks.5."]: number;
            ["transformer_blocks.6."]: number;
            ["transformer_blocks.7."]: number;
            ["transformer_blocks.8."]: number;
            ["transformer_blocks.9."]: number;
            ["transformer_blocks.10."]: number;
            ["transformer_blocks.11."]: number;
            ["transformer_blocks.12."]: number;
            ["transformer_blocks.13."]: number;
            ["transformer_blocks.14."]: number;
            ["transformer_blocks.15."]: number;
            ["transformer_blocks.16."]: number;
            ["transformer_blocks.17."]: number;
            ["transformer_blocks.18."]: number;
            ["transformer_blocks.19."]: number;
            ["transformer_blocks.20."]: number;
            ["transformer_blocks.21."]: number;
            ["transformer_blocks.22."]: number;
            ["transformer_blocks.23."]: number;
            ["transformer_blocks.24."]: number;
            ["transformer_blocks.25."]: number;
            ["transformer_blocks.26."]: number;
            ["transformer_blocks.27."]: number;
            ["transformer_blocks.28."]: number;
            ["transformer_blocks.29."]: number;
            ["transformer_blocks.30."]: number;
            ["transformer_blocks.31."]: number;
            ["transformer_blocks.32."]: number;
            ["transformer_blocks.33."]: number;
            ["transformer_blocks.34."]: number;
            ["transformer_blocks.35."]: number;
            ["transformer_blocks.36."]: number;
            ["transformer_blocks.37."]: number;
            ["transformer_blocks.38."]: number;
            ["transformer_blocks.39."]: number;
            ["transformer_blocks.40."]: number;
            ["transformer_blocks.41."]: number;
            ["transformer_blocks.42."]: number;
            ["transformer_blocks.43."]: number;
            ["transformer_blocks.44."]: number;
            ["transformer_blocks.45."]: number;
            ["transformer_blocks.46."]: number;
            ["transformer_blocks.47."]: number;
            ["transformer_blocks.48."]: number;
            ["transformer_blocks.49."]: number;
            ["transformer_blocks.50."]: number;
            ["transformer_blocks.51."]: number;
            ["transformer_blocks.52."]: number;
            ["transformer_blocks.53."]: number;
            ["transformer_blocks.54."]: number;
            ["transformer_blocks.55."]: number;
            ["transformer_blocks.56."]: number;
            ["transformer_blocks.57."]: number;
            ["transformer_blocks.58."]: number;
            ["transformer_blocks.59."]: number;
            ["proj_out."]: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PerturbedAttentionGuidance {
        /**
         * INPUT_TYPES: model, scale
         */
        inputs?: {
            model: unknown;
            scale: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface AlignYourStepsScheduler {
        /**
         * INPUT_TYPES: model_type, steps, denoise
         */
        inputs?: {
            model_type: string;
            steps: number;
            denoise: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface UNetSelfAttentionMultiply {
        /**
         * INPUT_TYPES: model, q, k, v, out
         */
        inputs?: {
            model: string;
            q: number;
            k: number;
            v: number;
            out: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface UNetCrossAttentionMultiply {
        /**
         * INPUT_TYPES: model, q, k, v, out
         */
        inputs?: {
            model: string;
            q: number;
            k: number;
            v: number;
            out: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPAttentionMultiply {
        /**
         * INPUT_TYPES: clip, q, k, v, out
         */
        inputs?: {
            clip: string;
            q: number;
            k: number;
            v: number;
            out: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface UNetTemporalAttentionMultiply {
        /**
         * INPUT_TYPES: model, self_structural, self_temporal, cross_structural, cross_temporal
         */
        inputs?: {
            model: string;
            self_structural: number;
            self_temporal: number;
            cross_structural: number;
            cross_temporal: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SamplerLCMUpscale {
        /**
         * INPUT_TYPES: scale_ratio, scale_steps, upscale_method
         */
        inputs?: {
            scale_ratio: number;
            scale_steps: number;
            upscale_method: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAMPLER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SamplerEulerCFGpp {
        /**
         * INPUT_TYPES: version
         */
        inputs?: {
            version: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAMPLER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface WebcamCapture {
        /**
         * INPUT_TYPES: image, width, height, capture_on_queue
         */
        inputs?: {
            image: unknown;
            width: number;
            height: number;
            capture_on_queue: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface EmptyLatentAudio {
        /**
         * INPUT_TYPES: seconds, batch_size
         */
        inputs?: {
            seconds: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface VAEEncodeAudio {
        /**
         * INPUT_TYPES: audio, vae
         */
        inputs?: {
            audio: unknown;
            vae: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface VAEDecodeAudio {
        /**
         * INPUT_TYPES: samples, vae
         */
        inputs?: {
            samples: unknown;
            vae: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AUDIO
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SaveAudio {
        /**
         * INPUT_TYPES: audio, filename_prefix
         */
        inputs?: {
            audio: unknown;
            filename_prefix: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface SaveAudioMP3 {
        /**
         * INPUT_TYPES: audio, filename_prefix, quality
         */
        inputs?: {
            audio: unknown;
            filename_prefix: string;
            quality: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface SaveAudioOpus {
        /**
         * INPUT_TYPES: audio, filename_prefix, quality
         */
        inputs?: {
            audio: unknown;
            filename_prefix: string;
            quality: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface LoadAudio {
        /**
         * INPUT_TYPES: audio
         */
        inputs?: {
            audio: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AUDIO
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PreviewAudio {
        /**
         * INPUT_TYPES: audio
         */
        inputs?: {
            audio: unknown;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface ConditioningStableAudio {
        /**
         * INPUT_TYPES: positive, negative, seconds_start, seconds_total
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            seconds_start: number;
            seconds_total: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface RecordAudio {
        /**
         * INPUT_TYPES: audio
         */
        inputs?: {
            audio: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AUDIO
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface TripleCLIPLoader {
        /**
         * INPUT_TYPES: clip_name1, clip_name2, clip_name3
         */
        inputs?: {
            clip_name1: string;
            clip_name2: string;
            clip_name3: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface EmptySD3LatentImage {
        /**
         * INPUT_TYPES: width, height, batch_size
         */
        inputs?: {
            width: number;
            height: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPTextEncodeSD3 {
        /**
         * INPUT_TYPES: clip, clip_l, clip_g, t5xxl, empty_padding
         */
        inputs?: {
            clip: unknown;
            clip_l: string;
            clip_g: string;
            t5xxl: string;
            empty_padding: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ControlNetApplySD3 {
        /**
         * INPUT_TYPES: positive, negative, control_net, vae, image, strength, start_percent, end_percent
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            control_net: unknown;
            vae: unknown;
            image: unknown;
            strength: number;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface SkipLayerGuidanceSD3 {
        /**
         * INPUT_TYPES: model, layers, scale, start_percent, end_percent
         */
        inputs?: {
            model: unknown;
            layers: string;
            scale: number;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface GITSScheduler {
        /**
         * INPUT_TYPES: coeff, steps, denoise
         */
        inputs?: {
            coeff: number;
            steps: number;
            denoise: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SetUnionControlNetType {
        /**
         * INPUT_TYPES: control_net, type
         */
        inputs?: {
            control_net: unknown;
            type: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ControlNetInpaintingAliMamaApply {
        /**
         * INPUT_TYPES: positive, negative, control_net, vae, image, mask, strength, start_percent, end_percent
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            control_net: unknown;
            vae: unknown;
            image: unknown;
            mask: unknown;
            strength: number;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface CLIPTextEncodeHunyuanDiT {
        /**
         * INPUT_TYPES: clip, bert, mt5xl
         */
        inputs?: {
            clip: unknown;
            bert: string;
            mt5xl: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface TextEncodeHunyuanVideo_ImageToVideo {
        /**
         * INPUT_TYPES: clip, clip_vision_output, prompt, image_interleave
         */
        inputs?: {
            clip: unknown;
            clip_vision_output: unknown;
            prompt: string;
            image_interleave: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface EmptyHunyuanLatentVideo {
        /**
         * INPUT_TYPES: width, height, length, batch_size
         */
        inputs?: {
            width: number;
            height: number;
            length: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface HunyuanImageToVideo {
        /**
         * INPUT_TYPES: positive, vae, width, height, length, batch_size, guidance_type
         */
        inputs?: {
            positive: unknown;
            vae: unknown;
            width: number;
            height: number;
            length: number;
            batch_size: number;
            guidance_type: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface CLIPTextEncodeFlux {
        /**
         * INPUT_TYPES: clip, clip_l, t5xxl, guidance
         */
        inputs?: {
            clip: unknown;
            clip_l: string;
            t5xxl: string;
            guidance: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface FluxGuidance {
        /**
         * INPUT_TYPES: conditioning, guidance
         */
        inputs?: {
            conditioning: unknown;
            guidance: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface FluxDisableGuidance {
        /**
         * INPUT_TYPES: conditioning
         */
        inputs?: {
            conditioning: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface FluxKontextImageScale {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface FluxKontextMultiReferenceLatentMethod {
        /**
         * INPUT_TYPES: conditioning, reference_latents_method
         */
        inputs?: {
            conditioning: unknown;
            reference_latents_method: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LoraSave {
        /**
         * INPUT_TYPES: filename_prefix, rank, lora_type, bias_diff
         */
        inputs?: {
            filename_prefix: string;
            rank: number;
            lora_type: string;
            bias_diff: unknown;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface TorchCompileModel {
        /**
         * INPUT_TYPES: model, backend
         */
        inputs?: {
            model: unknown;
            backend: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface EmptyMochiLatentVideo {
        /**
         * INPUT_TYPES: width, height, length, batch_size
         */
        inputs?: {
            width: number;
            height: number;
            length: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SkipLayerGuidanceDiT {
        /**
         * INPUT_TYPES: model, double_layers, single_layers, scale, start_percent, end_percent, rescaling_scale
         */
        inputs?: {
            model: unknown;
            double_layers: string;
            single_layers: string;
            scale: number;
            start_percent: number;
            end_percent: number;
            rescaling_scale: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SkipLayerGuidanceDiTSimple {
        /**
         * INPUT_TYPES: model, double_layers, single_layers, start_percent, end_percent
         */
        inputs?: {
            model: unknown;
            double_layers: string;
            single_layers: string;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mahiro {
        /**
         * INPUT_TYPES: model
         */
        inputs?: {
            model: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface EmptyLTXVLatentVideo {
        /**
         * INPUT_TYPES: width, height, length, batch_size
         */
        inputs?: {
            width: number;
            height: number;
            length: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LTXVImgToVideo {
        /**
         * INPUT_TYPES: positive, negative, vae, image, width, height, length, batch_size, strength
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            vae: unknown;
            image: unknown;
            width: number;
            height: number;
            length: number;
            batch_size: number;
            strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface ModelSamplingLTXV {
        /**
         * INPUT_TYPES: model, max_shift, base_shift
         */
        inputs?: {
            model: unknown;
            max_shift: number;
            base_shift: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LTXVConditioning {
        /**
         * INPUT_TYPES: positive, negative, frame_rate
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            frame_rate: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LTXVScheduler {
        /**
         * INPUT_TYPES: steps, max_shift, base_shift, stretch, terminal
         */
        inputs?: {
            steps: number;
            max_shift: number;
            base_shift: number;
            stretch: unknown;
            terminal: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LTXVAddGuide {
        /**
         * INPUT_TYPES: positive, negative, vae, latent, image, frame_idx, strength
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            vae: unknown;
            latent: unknown;
            image: unknown;
            frame_idx: number;
            strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LTXVPreprocess {
        /**
         * INPUT_TYPES: image, img_compression
         */
        inputs?: {
            image: unknown;
            img_compression: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LTXVCropGuides {
        /**
         * INPUT_TYPES: positive, negative, latent
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            latent: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface CreateHookLora {
        /**
         * INPUT_TYPES: lora_name, strength_model, strength_clip
         */
        inputs?: {
            lora_name: string;
            strength_model: number;
            strength_clip: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOKS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CreateHookLoraModelOnly {
        /**
         * INPUT_TYPES: lora_name, strength_model
         */
        inputs?: {
            lora_name: string;
            strength_model: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOKS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CreateHookModelAsLora {
        /**
         * INPUT_TYPES: ckpt_name, strength_model, strength_clip
         */
        inputs?: {
            ckpt_name: string;
            strength_model: number;
            strength_clip: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOKS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CreateHookModelAsLoraModelOnly {
        /**
         * INPUT_TYPES: ckpt_name, strength_model
         */
        inputs?: {
            ckpt_name: string;
            strength_model: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOKS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SetHookKeyframes {
        /**
         * INPUT_TYPES: hooks
         */
        inputs?: {
            hooks: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOKS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CreateHookKeyframe {
        /**
         * INPUT_TYPES: strength_mult, start_percent
         */
        inputs?: {
            strength_mult: number;
            start_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOK_KEYFRAMES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CreateHookKeyframesInterpolated {
        /**
         * INPUT_TYPES: strength_start, strength_end, interpolation, start_percent, end_percent, keyframes_count, print_keyframes
         */
        inputs?: {
            strength_start: number;
            strength_end: number;
            interpolation: string;
            start_percent: number;
            end_percent: number;
            keyframes_count: number;
            print_keyframes: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOK_KEYFRAMES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CreateHookKeyframesFromFloats {
        /**
         * INPUT_TYPES: floats_strength, start_percent, end_percent, print_keyframes
         */
        inputs?: {
            floats_strength: unknown;
            start_percent: number;
            end_percent: number;
            print_keyframes: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOK_KEYFRAMES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CombineHooks2 {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOKS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CombineHooks4 {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOKS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CombineHooks8 {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOKS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ConditioningSetProperties {
        /**
         * INPUT_TYPES: cond_NEW, strength, set_cond_area
         */
        inputs?: {
            cond_NEW: unknown;
            strength: number;
            set_cond_area: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ConditioningSetPropertiesAndCombine {
        /**
         * INPUT_TYPES: cond, cond_NEW, strength, set_cond_area
         */
        inputs?: {
            cond: unknown;
            cond_NEW: unknown;
            strength: number;
            set_cond_area: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PairConditioningSetProperties {
        /**
         * INPUT_TYPES: positive_NEW, negative_NEW, strength, set_cond_area
         */
        inputs?: {
            positive_NEW: unknown;
            negative_NEW: unknown;
            strength: number;
            set_cond_area: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface PairConditioningSetPropertiesAndCombine {
        /**
         * INPUT_TYPES: positive, negative, positive_NEW, negative_NEW, strength, set_cond_area
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            positive_NEW: unknown;
            negative_NEW: unknown;
            strength: number;
            set_cond_area: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ConditioningSetDefaultCombine {
        /**
         * INPUT_TYPES: cond, cond_DEFAULT
         */
        inputs?: {
            cond: unknown;
            cond_DEFAULT: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PairConditioningSetDefaultCombine {
        /**
         * INPUT_TYPES: positive, negative, positive_DEFAULT, negative_DEFAULT
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            positive_DEFAULT: unknown;
            negative_DEFAULT: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface PairConditioningCombine {
        /**
         * INPUT_TYPES: positive_A, negative_A, positive_B, negative_B
         */
        inputs?: {
            positive_A: unknown;
            negative_A: unknown;
            positive_B: unknown;
            negative_B: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface SetClipHooks {
        /**
         * INPUT_TYPES: clip, apply_to_conds, schedule_clip
         */
        inputs?: {
            clip: unknown;
            apply_to_conds: unknown;
            schedule_clip: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ConditioningTimestepsRange {
        /**
         * INPUT_TYPES: start_percent, end_percent
         */
        inputs?: {
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: TIMESTEPS_RANGE, TIMESTEPS_RANGE, TIMESTEPS_RANGE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Load3D {
        /**
         * INPUT_TYPES: model_file, image, width, height
         */
        inputs?: {
            model_file: string;
            image: unknown;
            width: number;
            height: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, STRING, IMAGE, IMAGE, LOAD3D_CAMERA, VIDEO
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Load3DAnimation {
        /**
         * INPUT_TYPES: model_file, image, width, height
         */
        inputs?: {
            model_file: string;
            image: unknown;
            width: number;
            height: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, STRING, IMAGE, LOAD3D_CAMERA, VIDEO
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Preview3D {
        /**
         * INPUT_TYPES: model_file
         */
        inputs?: {
            model_file: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface Preview3DAnimation {
        /**
         * INPUT_TYPES: model_file
         */
        inputs?: {
            model_file: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface EmptyCosmosLatentVideo {
        /**
         * INPUT_TYPES: width, height, length, batch_size
         */
        inputs?: {
            width: number;
            height: number;
            length: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CosmosImageToVideoLatent {
        /**
         * INPUT_TYPES: vae, width, height, length, batch_size
         */
        inputs?: {
            vae: unknown;
            width: number;
            height: number;
            length: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CosmosPredict2ImageToVideoLatent {
        /**
         * INPUT_TYPES: vae, width, height, length, batch_size
         */
        inputs?: {
            vae: unknown;
            width: number;
            height: number;
            length: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SaveWEBM {
        /**
         * INPUT_TYPES: images, filename_prefix, codec, fps, crf
         */
        inputs?: {
            images: unknown;
            filename_prefix: string;
            codec: string;
            fps: number;
            crf: number;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface SaveVideo {
        /**
         * INPUT_TYPES: video, filename_prefix, format, codec
         */
        inputs?: {
            video: string;
            filename_prefix: string;
            format: string;
            codec: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface CreateVideo {
        /**
         * INPUT_TYPES: images, fps
         */
        inputs?: {
            images: string;
            fps: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: VIDEO
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface GetVideoComponents {
        /**
         * INPUT_TYPES: video
         */
        inputs?: {
            video: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, AUDIO, FLOAT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LoadVideo {
        /**
         * INPUT_TYPES: file
         */
        inputs?: {
            file: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: VIDEO
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPTextEncodeLumina2 {
        /**
         * INPUT_TYPES: system_prompt, user_prompt, clip
         */
        inputs?: {
            system_prompt: string;
            user_prompt: string;
            clip: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface RenormCFG {
        /**
         * INPUT_TYPES: model, cfg_trunc, renorm_cfg
         */
        inputs?: {
            model: unknown;
            cfg_trunc: number;
            renorm_cfg: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface WanTrackToVideo {
        /**
         * INPUT_TYPES: positive, negative, vae, tracks, width, height, length, batch_size, temperature, topk, start_image
         */
        inputs?: {
            positive: string;
            negative: string;
            vae: string;
            tracks: string;
            width: number;
            height: number;
            length: number;
            batch_size: number;
            temperature: number;
            topk: number;
            start_image: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface WanImageToVideo {
        /**
         * INPUT_TYPES: positive, negative, vae, width, height, length, batch_size
         */
        inputs?: {
            positive: string;
            negative: string;
            vae: string;
            width: number;
            height: number;
            length: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface WanFunControlToVideo {
        /**
         * INPUT_TYPES: positive, negative, vae, width, height, length, batch_size
         */
        inputs?: {
            positive: string;
            negative: string;
            vae: string;
            width: number;
            height: number;
            length: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Wan22FunControlToVideo {
        /**
         * INPUT_TYPES: positive, negative, vae, width, height, length, batch_size
         */
        inputs?: {
            positive: string;
            negative: string;
            vae: string;
            width: number;
            height: number;
            length: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface WanFunInpaintToVideo {
        /**
         * INPUT_TYPES: positive, negative, vae, width, height, length, batch_size
         */
        inputs?: {
            positive: string;
            negative: string;
            vae: string;
            width: number;
            height: number;
            length: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface WanFirstLastFrameToVideo {
        /**
         * INPUT_TYPES: positive, negative, vae, width, height, length, batch_size
         */
        inputs?: {
            positive: string;
            negative: string;
            vae: string;
            width: number;
            height: number;
            length: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface WanVaceToVideo {
        /**
         * INPUT_TYPES: positive, negative, vae, width, height, length, batch_size, strength
         */
        inputs?: {
            positive: string;
            negative: string;
            vae: string;
            width: number;
            height: number;
            length: number;
            batch_size: number;
            strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface TrimVideoLatent {
        /**
         * INPUT_TYPES: samples, trim_amount
         */
        inputs?: {
            samples: string;
            trim_amount: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface WanCameraImageToVideo {
        /**
         * INPUT_TYPES: positive, negative, vae, width, height, length, batch_size
         */
        inputs?: {
            positive: string;
            negative: string;
            vae: string;
            width: number;
            height: number;
            length: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface WanPhantomSubjectToVideo {
        /**
         * INPUT_TYPES: positive, negative, vae, width, height, length, batch_size
         */
        inputs?: {
            positive: string;
            negative: string;
            vae: string;
            width: number;
            height: number;
            length: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface WanSoundImageToVideo {
        /**
         * INPUT_TYPES: positive, negative, vae, width, height, length, batch_size
         */
        inputs?: {
            positive: string;
            negative: string;
            vae: string;
            width: number;
            height: number;
            length: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface WanSoundImageToVideoExtend {
        /**
         * INPUT_TYPES: positive, negative, vae, length, video_latent
         */
        inputs?: {
            positive: string;
            negative: string;
            vae: string;
            length: number;
            video_latent: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Wan22ImageToVideoLatent {
        /**
         * INPUT_TYPES: vae, width, height, length, batch_size
         */
        inputs?: {
            vae: string;
            width: number;
            height: number;
            length: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LotusConditioning {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface EmptyLatentHunyuan3Dv2 {
        /**
         * INPUT_TYPES: resolution, batch_size
         */
        inputs?: {
            resolution: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Hunyuan3Dv2Conditioning {
        /**
         * INPUT_TYPES: clip_vision_output
         */
        inputs?: {
            clip_vision_output: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Hunyuan3Dv2ConditioningMultiView {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface VAEDecodeHunyuan3D {
        /**
         * INPUT_TYPES: samples, vae, num_chunks, octree_resolution
         */
        inputs?: {
            samples: unknown;
            vae: unknown;
            num_chunks: number;
            octree_resolution: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: VOXEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface VoxelToMeshBasic {
        /**
         * INPUT_TYPES: voxel, threshold
         */
        inputs?: {
            voxel: unknown;
            threshold: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MESH
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface VoxelToMesh {
        /**
         * INPUT_TYPES: voxel, algorithm, threshold
         */
        inputs?: {
            voxel: unknown;
            algorithm: string;
            threshold: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MESH
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SaveGLB {
        /**
         * INPUT_TYPES: mesh, filename_prefix
         */
        inputs?: {
            mesh: unknown;
            filename_prefix: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface PrimitiveString {
        /**
         * INPUT_TYPES: value
         */
        inputs?: {
            value: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PrimitiveStringMultiline {
        /**
         * INPUT_TYPES: value
         */
        inputs?: {
            value: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PrimitiveInt {
        /**
         * INPUT_TYPES: value
         */
        inputs?: {
            value: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PrimitiveFloat {
        /**
         * INPUT_TYPES: value
         */
        inputs?: {
            value: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PrimitiveBoolean {
        /**
         * INPUT_TYPES: value
         */
        inputs?: {
            value: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CFGZeroStar {
        /**
         * INPUT_TYPES: model
         */
        inputs?: {
            model: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CFGNorm {
        /**
         * INPUT_TYPES: model, strength
         */
        inputs?: {
            model: unknown;
            strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface OptimalStepsScheduler {
        /**
         * INPUT_TYPES: model_type, steps, denoise
         */
        inputs?: {
            model_type: string;
            steps: number;
            denoise: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface QuadrupleCLIPLoader {
        /**
         * INPUT_TYPES: clip_name1, clip_name2, clip_name3, clip_name4
         */
        inputs?: {
            clip_name1: string;
            clip_name2: string;
            clip_name3: string;
            clip_name4: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPTextEncodeHiDream {
        /**
         * INPUT_TYPES: clip, clip_l, clip_g, t5xxl, llama
         */
        inputs?: {
            clip: unknown;
            clip_l: string;
            clip_g: string;
            t5xxl: string;
            llama: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface FreSca {
        /**
         * INPUT_TYPES: model, scale_low, scale_high, freq_cutoff
         */
        inputs?: {
            model: unknown;
            scale_low: number;
            scale_high: number;
            freq_cutoff: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface APG {
        /**
         * INPUT_TYPES: model, eta, norm_threshold, momentum
         */
        inputs?: {
            model: string;
            eta: number;
            norm_threshold: number;
            momentum: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PreviewAny {
        /**
         * INPUT_TYPES: source
         */
        inputs?: {
            source: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface TextEncodeAceStepAudio {
        /**
         * INPUT_TYPES: clip, tags, lyrics, lyrics_strength
         */
        inputs?: {
            clip: string;
            tags: string;
            lyrics: string;
            lyrics_strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface EmptyAceStepLatentAudio {
        /**
         * INPUT_TYPES: seconds, batch_size
         */
        inputs?: {
            seconds: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface StringConcatenate {
        /**
         * INPUT_TYPES: string_a, string_b, delimiter
         */
        inputs?: {
            string_a: string;
            string_b: string;
            delimiter: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface StringSubstring {
        /**
         * INPUT_TYPES: string, start, end
         */
        inputs?: {
            string: string;
            start: number;
            end: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface StringLength {
        /**
         * INPUT_TYPES: string
         */
        inputs?: {
            string: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CaseConverter {
        /**
         * INPUT_TYPES: string, mode
         */
        inputs?: {
            string: string;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface StringTrim {
        /**
         * INPUT_TYPES: string, mode
         */
        inputs?: {
            string: string;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface StringReplace {
        /**
         * INPUT_TYPES: string, find, replace
         */
        inputs?: {
            string: string;
            find: string;
            replace: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface StringContains {
        /**
         * INPUT_TYPES: string, substring, case_sensitive
         */
        inputs?: {
            string: string;
            substring: string;
            case_sensitive: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface StringCompare {
        /**
         * INPUT_TYPES: string_a, string_b, mode, case_sensitive
         */
        inputs?: {
            string_a: string;
            string_b: string;
            mode: string;
            case_sensitive: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface RegexMatch {
        /**
         * INPUT_TYPES: string, regex_pattern, case_insensitive, multiline, dotall
         */
        inputs?: {
            string: string;
            regex_pattern: string;
            case_insensitive: string;
            multiline: string;
            dotall: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface RegexExtract {
        /**
         * INPUT_TYPES: string, regex_pattern, mode, case_insensitive, multiline, dotall, group_index
         */
        inputs?: {
            string: string;
            regex_pattern: string;
            mode: string;
            case_insensitive: string;
            multiline: string;
            dotall: string;
            group_index: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface RegexReplace {
        /**
         * INPUT_TYPES: string, regex_pattern, replace
         */
        inputs?: {
            string: string;
            regex_pattern: string;
            replace: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface WanCameraEmbedding {
        /**
         * INPUT_TYPES: camera_pose, width, height, length
         */
        inputs?: {
            camera_pose: string;
            width: number;
            height: number;
            length: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: WAN_CAMERA_EMBEDDING, INT, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface ReferenceLatent {
        /**
         * INPUT_TYPES: conditioning
         */
        inputs?: {
            conditioning: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface TCFG {
        /**
         * INPUT_TYPES: model
         */
        inputs?: {
            model: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ContextWindowsManual {
        /**
         * INPUT_TYPES: model, context_length, context_overlap, context_schedule, context_stride, closed_loop, fuse_method, dim
         */
        inputs?: {
            model: string;
            context_length: number;
            context_overlap: number;
            context_schedule: string;
            context_stride: number;
            closed_loop: string;
            fuse_method: string;
            dim: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface WanContextWindowsManual {
        /**
         * INPUT_TYPES: model, context_length, context_overlap, context_schedule, context_stride, closed_loop, fuse_method
         */
        inputs?: {
            model: string;
            context_length: number;
            context_overlap: number;
            context_schedule: string;
            context_stride: number;
            closed_loop: string;
            fuse_method: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface TextEncodeQwenImageEdit {
        /**
         * INPUT_TYPES: clip, prompt
         */
        inputs?: {
            clip: unknown;
            prompt: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelPatchLoader {
        /**
         * INPUT_TYPES: name
         */
        inputs?: {
            name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL_PATCH
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface QwenImageDiffsynthControlnet {
        /**
         * INPUT_TYPES: model, model_patch, vae, image, strength
         */
        inputs?: {
            model: unknown;
            model_patch: unknown;
            vae: unknown;
            image: unknown;
            strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface EasyCache {
        /**
         * INPUT_TYPES: model, reuse_threshold, start_percent, end_percent, verbose
         */
        inputs?: {
            model: string;
            reuse_threshold: number;
            start_percent: number;
            end_percent: number;
            verbose: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LazyCache {
        /**
         * INPUT_TYPES: model, reuse_threshold, start_percent, end_percent, verbose
         */
        inputs?: {
            model: string;
            reuse_threshold: number;
            start_percent: number;
            end_percent: number;
            verbose: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface AudioEncoderLoader {
        /**
         * INPUT_TYPES: audio_encoder_name
         */
        inputs?: {
            audio_encoder_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AUDIO_ENCODER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface AudioEncoderEncode {
        /**
         * INPUT_TYPES: audio_encoder, audio
         */
        inputs?: {
            audio_encoder: unknown;
            audio: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AUDIO_ENCODER_OUTPUT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Animation_Builder__mtb_ {
        /**
         * INPUT_TYPES: total_frames, scale_float, loop_count, raw_iteration, raw_loop
         */
        inputs?: {
            total_frames: number;
            scale_float: number;
            loop_count: number;
            raw_iteration: number;
            raw_loop: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, FLOAT, INT, BOOLEAN
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Audio_Sequence__mtb_ {
        /**
         * INPUT_TYPES: silence_duration
         */
        inputs?: {
            silence_duration: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AUDIO
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Audio_Stack__mtb_ {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AUDIO
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Audio_Cut__mtb_ {
        /**
         * INPUT_TYPES: audio, length, offset
         */
        inputs?: {
            audio: unknown;
            length: number;
            offset: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AUDIO
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Audio_Resample__mtb_ {
        /**
         * INPUT_TYPES: audio, sample_rate
         */
        inputs?: {
            audio: unknown;
            sample_rate: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AUDIO
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Audio_Isolate_Speaker__mtb_ {
        /**
         * INPUT_TYPES: audio, whisper_data, target_speaker, mode, fade_ms
         */
        inputs?: {
            audio: unknown;
            whisper_data: unknown;
            target_speaker: string;
            mode: string;
            fade_ms: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AUDIO
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Load_Whisper__mtb_ {
        /**
         * INPUT_TYPES: model_size
         */
        inputs?: {
            model_size: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: WHISPER_PIPELINE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Audio_To_Text__mtb_ {
        /**
         * INPUT_TYPES: pipeline, audio, language, return_timestamps
         */
        inputs?: {
            pipeline: unknown;
            audio: unknown;
            language: string;
            return_timestamps: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, WHISPER_OUTPUT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Process_Whisper_Output__mtb_ {
        /**
         * INPUT_TYPES: whisper_output, min_chunk_length
         */
        inputs?: {
            whisper_output: unknown;
            min_chunk_length: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, WHISPER_CHUNKS
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Process_Whisper_Diarization__mtb_ {
        /**
         * INPUT_TYPES: whisper_chunks, audio, backend, num_speakers
         */
        inputs?: {
            whisper_chunks: unknown;
            audio: unknown;
            backend: string;
            num_speakers: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: WHISPER_CHUNKS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Audio_Duration__mtb_ {
        /**
         * INPUT_TYPES: audio
         */
        inputs?: {
            audio: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Batch2d_Transform__mtb_ {
        /**
         * INPUT_TYPES: image, border_handling, constant_color
         */
        inputs?: {
            image: unknown;
            border_handling: string;
            constant_color: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Batch_Float__mtb_ {
        /**
         * INPUT_TYPES: mode, count, min, max, easing
         */
        inputs?: {
            mode: string;
            count: number;
            min: number;
            max: number;
            easing: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOATS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Batch_Float_Assemble__mtb_ {
        /**
         * INPUT_TYPES: reverse
         */
        inputs?: {
            reverse: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOATS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Batch_Float_Fill__mtb_ {
        /**
         * INPUT_TYPES: floats, direction, value, count
         */
        inputs?: {
            floats: unknown;
            direction: string;
            value: number;
            count: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOATS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Batch_Float_Fit__mtb_ {
        /**
         * INPUT_TYPES: values, clamp, auto_compute_source, source_min, source_max, target_min, target_max, easing
         */
        inputs?: {
            values: unknown;
            clamp: unknown;
            auto_compute_source: unknown;
            source_min: number;
            source_max: number;
            target_min: number;
            target_max: number;
            easing: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOATS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Batch_Float_Math__mtb_ {
        /**
         * INPUT_TYPES: reverse, operation
         */
        inputs?: {
            reverse: unknown;
            operation: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOATS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Batch_Float_Normalize__mtb_ {
        /**
         * INPUT_TYPES: floats
         */
        inputs?: {
            floats: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOATS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Batch_From_Folder__mtb_ {
        /**
         * INPUT_TYPES: enable, folder_path, mode, count, filter
         */
        inputs?: {
            enable: unknown;
            folder_path: string;
            mode: string;
            count: number;
            filter: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Batch_Make__mtb_ {
        /**
         * INPUT_TYPES: image, count
         */
        inputs?: {
            image: unknown;
            count: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Batch_Merge__mtb_ {
        /**
         * INPUT_TYPES: fusion_mode, fill
         */
        inputs?: {
            fusion_mode: string;
            fill: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Batch_Sequence__mtb_ {
        /**
         * INPUT_TYPES: reverse
         */
        inputs?: {
            reverse: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Batch_Sequence_Plus__mtb_ {
        /**
         * INPUT_TYPES: transition, overlap_frames, reverse
         */
        inputs?: {
            transition: string;
            overlap_frames: number;
            reverse: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Batch_Shake__mtb_ {
        /**
         * INPUT_TYPES: images, position_amount_x, position_amount_y, rotation_amount, frequency, frequency_divider, octaves, seed
         */
        inputs?: {
            images: unknown;
            position_amount_x: number;
            position_amount_y: number;
            rotation_amount: number;
            frequency: number;
            frequency_divider: number;
            octaves: number;
            seed: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, FLOATS, FLOATS, FLOATS
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Batch_Shape__mtb_ {
        /**
         * INPUT_TYPES: count, shape, image_width, image_height, shape_size, color, bg_color, shade_color, thickness, shadex, shadey
         */
        inputs?: {
            count: number;
            shape: string;
            image_width: number;
            image_height: number;
            shape_size: number;
            color: unknown;
            bg_color: unknown;
            shade_color: unknown;
            thickness: number;
            shadex: number;
            shadey: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Batch_Time_Wrap__mtb_ {
        /**
         * INPUT_TYPES: target_count, frames, curve
         */
        inputs?: {
            target_count: number;
            frames: unknown;
            curve: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, FLOATS
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Plot_Batch_Float__mtb_ {
        /**
         * INPUT_TYPES: width, height, point_size, seed, start_at_zero
         */
        inputs?: {
            width: number;
            height: number;
            point_size: number;
            seed: number;
            start_at_zero: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Sublist_To_Image_Batch__mtb_ {
        /**
         * INPUT_TYPES: tensors
         */
        inputs?: {
            tensors: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Batch_To_Sublist__mtb_ {
        /**
         * INPUT_TYPES: sub_batch_size
         */
        inputs?: {
            sub_batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Smart_Step__mtb_ {
        /**
         * INPUT_TYPES: step, start_percent, end_percent
         */
        inputs?: {
            step: number;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, INT, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Styles_Loader__mtb_ {
        /**
         * INPUT_TYPES: style_name
         */
        inputs?: {
            style_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Interpolate_Clip_Sequential__mtb_ {
        /**
         * INPUT_TYPES: base_text, text_to_replace, clip, interpolation_strength
         */
        inputs?: {
            base_text: string;
            text_to_replace: string;
            clip: unknown;
            interpolation_strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Interpolate_Condition__mtb_ {
        /**
         * INPUT_TYPES: blend
         */
        inputs?: {
            blend: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Bbox_From_Mask__mtb_ {
        /**
         * INPUT_TYPES: mask, invert
         */
        inputs?: {
            mask: unknown;
            invert: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BBOX, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Bbox__mtb_ {
        /**
         * INPUT_TYPES: x, y, width, height
         */
        inputs?: {
            x: number;
            y: number;
            width: number;
            height: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BBOX
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Crop__mtb_ {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, BBOX
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Uncrop__mtb_ {
        /**
         * INPUT_TYPES: image, crop_image, bbox, border_blending
         */
        inputs?: {
            image: unknown;
            crop_image: unknown;
            bbox: unknown;
            border_blending: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Split_Bbox__mtb_ {
        /**
         * INPUT_TYPES: bbox
         */
        inputs?: {
            bbox: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, INT, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Upscale_Bbox_By__mtb_ {
        /**
         * INPUT_TYPES: bbox, scale
         */
        inputs?: {
            bbox: unknown;
            scale: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BBOX
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface BBox_Force_Dimensions__mtb_ {
        /**
         * INPUT_TYPES: bbox, width, height
         */
        inputs?: {
            bbox: unknown;
            width: number;
            height: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BBOX
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Curve__mtb_ {
        /**
         * INPUT_TYPES: curve
         */
        inputs?: {
            curve: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT_CURVE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Curve_To_Float__mtb_ {
        /**
         * INPUT_TYPES: curve, steps
         */
        inputs?: {
            curve: unknown;
            steps: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOATS, FLOAT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Debug__mtb_ {
        /**
         * INPUT_TYPES: output_to_console
         */
        inputs?: {
            output_to_console: unknown;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface Save_Tensors__mtb_ {
        /**
         * INPUT_TYPES: filename_prefix
         */
        inputs?: {
            filename_prefix: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface Deep_Bump__mtb_ {
        /**
         * INPUT_TYPES: image, mode, color_to_normals_overlap, normals_to_curvature_blur_radius, normals_to_height_seamless
         */
        inputs?: {
            image: unknown;
            mode: string;
            color_to_normals_overlap: string;
            normals_to_curvature_blur_radius: string;
            normals_to_height_seamless: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Restore_Face__mtb_ {
        /**
         * INPUT_TYPES: image, model, aligned, only_center_face, weight, save_tmp_steps
         */
        inputs?: {
            image: unknown;
            model: unknown;
            aligned: unknown;
            only_center_face: unknown;
            weight: number;
            save_tmp_steps: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Load_Face_Enhance_Model__mtb_ {
        /**
         * INPUT_TYPES: model_name, upscale
         */
        inputs?: {
            model_name: string;
            upscale: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FACEENHANCE_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Face_Swap__mtb_ {
        /**
         * INPUT_TYPES: image, reference, faces_index, faceanalysis_model, faceswap_model
         */
        inputs?: {
            image: unknown;
            reference: unknown;
            faces_index: string;
            faceanalysis_model: unknown;
            faceswap_model: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Load_Face_Swap_Model__mtb_ {
        /**
         * INPUT_TYPES: faceswap_model
         */
        inputs?: {
            faceswap_model: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FACESWAP_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Load_Face_Analysis_Model__mtb_ {
        /**
         * INPUT_TYPES: faceswap_model
         */
        inputs?: {
            faceswap_model: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FACE_ANALYSIS_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Filter_Z__mtb_ {
        /**
         * INPUT_TYPES: image, depth, to_black, threshold, invert
         */
        inputs?: {
            image: unknown;
            depth: unknown;
            to_black: unknown;
            threshold: number;
            invert: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Unsplash_Image__mtb_ {
        /**
         * INPUT_TYPES: width, height, random_seed
         */
        inputs?: {
            width: number;
            height: number;
            random_seed: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_To_Image__mtb_ {
        /**
         * INPUT_TYPES: text, font, wrap, trim, line_height, font_size, width, height, color, background, h_align, v_align, h_offset, v_offset, h_coverage
         */
        inputs?: {
            text: string;
            font: string;
            wrap: unknown;
            trim: unknown;
            line_height: number;
            font_size: number;
            width: number;
            height: number;
            color: unknown;
            background: unknown;
            h_align: string;
            v_align: string;
            h_offset: number;
            v_offset: number;
            h_coverage: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface String_Replace__mtb_ {
        /**
         * INPUT_TYPES: string, old, new, use_regex
         */
        inputs?: {
            string: string;
            old: string;
            new: string;
            use_regex: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Fit_Number__mtb_ {
        /**
         * INPUT_TYPES: value, clamp, source_min, source_max, target_min, target_max, easing
         */
        inputs?: {
            value: number;
            clamp: unknown;
            source_min: number;
            source_max: number;
            target_min: number;
            target_max: number;
            easing: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Get_Batch_From_History__mtb_ {
        /**
         * INPUT_TYPES: enable, count, offset, internal_count
         */
        inputs?: {
            enable: unknown;
            count: number;
            offset: number;
            internal_count: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Any_To_String__mtb_ {
        /**
         * INPUT_TYPES: input
         */
        inputs?: {
            input: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Concat_Images__mtb_ {
        /**
         * INPUT_TYPES: reverse
         */
        inputs?: {
            reverse: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Math_Expression__mtb_ {
        /**
         * INPUT_TYPES: expression
         */
        inputs?: {
            expression: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT, INT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface To_Device__mtb_ {
        /**
         * INPUT_TYPES: ignore_errors, device
         */
        inputs?: {
            ignore_errors: unknown;
            device: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Apply_Text_Template__mtb_ {
        /**
         * INPUT_TYPES: template
         */
        inputs?: {
            template: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Match_Dimensions__mtb_ {
        /**
         * INPUT_TYPES: source, reference, match
         */
        inputs?: {
            source: unknown;
            reference: unknown;
            match: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, INT, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Auto_Pan_Equilateral__mtb_ {
        /**
         * INPUT_TYPES: equilateral_image, fovX, fovY, elevation, frame_count, width, height
         */
        inputs?: {
            equilateral_image: unknown;
            fovX: number;
            fovY: number;
            elevation: number;
            frame_count: number;
            width: number;
            height: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Floats_To_Float__mtb_ {
        /**
         * INPUT_TYPES: floats
         */
        inputs?: {
            floats: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Float_To_Floats__mtb_ {
        /**
         * INPUT_TYPES: float
         */
        inputs?: {
            float: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOATS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Floats_To_Ints__mtb_ {
        /**
         * INPUT_TYPES: floats
         */
        inputs?: {
            floats: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INTS, INT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Tensor_Ops__mtb_ {
        /**
         * INPUT_TYPES: tensor, operation, value, source_min, source_max, target_min, target_max, dtype, use_mean
         */
        inputs?: {
            tensor: unknown;
            operation: string;
            value: number;
            source_min: number;
            source_max: number;
            target_min: number;
            target_max: number;
            dtype: string;
            use_mean: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Color_Correct__mtb_ {
        /**
         * INPUT_TYPES: image, clamp, gamma, contrast, exposure, offset, hue, saturation, value
         */
        inputs?: {
            image: unknown;
            clamp: string;
            gamma: number;
            contrast: number;
            exposure: number;
            offset: number;
            hue: number;
            saturation: number;
            value: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Color_Correct_GPU__mtb_ {
        /**
         * INPUT_TYPES: image, force_gpu, clamp, gamma, contrast, exposure, offset, hue, saturation, value
         */
        inputs?: {
            image: unknown;
            force_gpu: unknown;
            clamp: string;
            gamma: number;
            contrast: number;
            exposure: number;
            offset: number;
            hue: number;
            saturation: number;
            value: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Compare__mtb_ {
        /**
         * INPUT_TYPES: imageA, imageB, mode
         */
        inputs?: {
            imageA: unknown;
            imageB: unknown;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Tile_Offset__mtb_ {
        /**
         * INPUT_TYPES: image, tilesX, tilesY
         */
        inputs?: {
            image: unknown;
            tilesX: number;
            tilesY: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Blur__mtb_ {
        /**
         * INPUT_TYPES: image, sigmaX, sigmaY
         */
        inputs?: {
            image: unknown;
            sigmaX: number;
            sigmaY: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_To_Image__mtb_ {
        /**
         * INPUT_TYPES: mask, color, background
         */
        inputs?: {
            mask: unknown;
            color: unknown;
            background: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Colored_Image__mtb_ {
        /**
         * INPUT_TYPES: color, width, height
         */
        inputs?: {
            color: unknown;
            width: number;
            height: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Premultiply__mtb_ {
        /**
         * INPUT_TYPES: image, mask, invert
         */
        inputs?: {
            image: unknown;
            mask: unknown;
            invert: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Resize_Factor__mtb_ {
        /**
         * INPUT_TYPES: image, factor, supersample, resampling
         */
        inputs?: {
            image: unknown;
            factor: number;
            supersample: unknown;
            resampling: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Save_Image_Grid__mtb_ {
        /**
         * INPUT_TYPES: images, filename_prefix, save_intermediate
         */
        inputs?: {
            images: unknown;
            filename_prefix: string;
            save_intermediate: unknown;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface Load_Image_From_Url__mtb_ {
        /**
         * INPUT_TYPES: url
         */
        inputs?: {
            url: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Sharpen__mtb_ {
        /**
         * INPUT_TYPES: image, sharpen_radius, sigma_x, sigma_y, alpha
         */
        inputs?: {
            image: unknown;
            sharpen_radius: number;
            sigma_x: number;
            sigma_y: number;
            alpha: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Extract_Coordinates_From_Image__mtb_ {
        /**
         * INPUT_TYPES: threshold, max_points
         */
        inputs?: {
            threshold: number;
            max_points: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BATCH_COORDINATES, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Coordinates_To_String__mtb_ {
        /**
         * INPUT_TYPES: coordinates, frame
         */
        inputs?: {
            coordinates: unknown;
            frame: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Stack_Images__mtb_ {
        /**
         * INPUT_TYPES: vertical
         */
        inputs?: {
            vertical: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Pick_From_Batch__mtb_ {
        /**
         * INPUT_TYPES: image, from_direction, count
         */
        inputs?: {
            image: unknown;
            from_direction: string;
            count: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Save_Image__mtb_ {
        /**
         * INPUT_TYPES: images, filename_prefix
         */
        inputs?: {
            images: unknown;
            filename_prefix: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Save_Gif__mtb_ {
        /**
         * INPUT_TYPES: image, fps, resize_by, optimize, pingpong, resample_filter, use_ffmpeg
         */
        inputs?: {
            image: unknown;
            fps: number;
            resize_by: number;
            optimize: unknown;
            pingpong: unknown;
            resample_filter: string;
            use_ffmpeg: unknown;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface Export_With_Ffmpeg__mtb_ {
        /**
         * INPUT_TYPES: fps, prefix, format, codec
         */
        inputs?: {
            fps: number;
            prefix: string;
            format: string;
            codec: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: VIDEO
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Add_To_Playlist__mtb_ {
        /**
         * INPUT_TYPES: relative_paths, persistant_playlist, playlist_name, index
         */
        inputs?: {
            relative_paths: unknown;
            persistant_playlist: unknown;
            playlist_name: string;
            index: number;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface Read_Playlist__mtb_ {
        /**
         * INPUT_TYPES: enable, persistant_playlist, playlist_name, index
         */
        inputs?: {
            enable: unknown;
            persistant_playlist: unknown;
            playlist_name: string;
            index: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: PLAYLIST
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Latent_Lerp__mtb_ {
        /**
         * INPUT_TYPES: A, B, t
         */
        inputs?: {
            A: unknown;
            B: unknown;
            t: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_H264_Compression__mtb_ {
        /**
         * INPUT_TYPES: image, crf
         */
        inputs?: {
            image: unknown;
            crf: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Remove_Background_Rembg__mtb_ {
        /**
         * INPUT_TYPES: image, alpha_matting, alpha_matting_foreground_threshold, alpha_matting_background_threshold, alpha_matting_erode_size, post_process_mask, bgcolor
         */
        inputs?: {
            image: unknown;
            alpha_matting: unknown;
            alpha_matting_foreground_threshold: number;
            alpha_matting_background_threshold: number;
            alpha_matting_erode_size: number;
            post_process_mask: unknown;
            bgcolor: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, IMAGE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Model_Patch_Seamless__mtb_ {
        /**
         * INPUT_TYPES: model, startStep, stopStep, tilingX, tilingY
         */
        inputs?: {
            model: unknown;
            startStep: number;
            stopStep: number;
            tilingX: unknown;
            tilingY: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, MODEL
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Vae_Decode__mtb_ {
        /**
         * INPUT_TYPES: samples, vae, seamless_model, use_tiling_decoder, tile_size
         */
        inputs?: {
            samples: unknown;
            vae: unknown;
            seamless_model: unknown;
            use_tiling_decoder: unknown;
            tile_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Float_To_Number__mtb_ {
        /**
         * INPUT_TYPES: float
         */
        inputs?: {
            float: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NUMBER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Int_To_Bool__mtb_ {
        /**
         * INPUT_TYPES: int
         */
        inputs?: {
            int: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Int_To_Number__mtb_ {
        /**
         * INPUT_TYPES: int
         */
        inputs?: {
            int: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NUMBER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Postshot_Export__mtb_ {
        /**
         * INPUT_TYPES: project_file, export_splat_ply, postshot_cli
         */
        inputs?: {
            project_file: string;
            export_splat_ply: string;
            postshot_cli: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Postshot_Train__mtb_ {
        /**
         * INPUT_TYPES: images, profile, image_select, train_steps_limit, output_path, postshot_cli
         */
        inputs?: {
            images: unknown;
            profile: string;
            image_select: string;
            train_steps_limit: number;
            output_path: string;
            postshot_cli: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Model_Pruner__mtb_ {
        /**
         * INPUT_TYPES: save_separately, save_folder, fix_clip, remove_junk, ema_mode, precision_unet, operation_unet, precision_clip, operation_clip, precision_vae, operation_vae
         */
        inputs?: {
            save_separately: unknown;
            save_folder: string;
            fix_clip: unknown;
            remove_junk: unknown;
            ema_mode: string;
            precision_unet: string;
            operation_unet: string;
            precision_clip: string;
            operation_clip: string;
            precision_vae: string;
            operation_vae: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface Qr_Code__mtb_ {
        /**
         * INPUT_TYPES: url, width, height, error_correct, box_size, border, invert
         */
        inputs?: {
            url: string;
            width: number;
            height: number;
            error_correct: string;
            box_size: number;
            border: number;
            invert: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Transform_Image__mtb_ {
        /**
         * INPUT_TYPES: image, x, y, zoom, angle, shear, border_handling, constant_color
         */
        inputs?: {
            image: unknown;
            x: number;
            y: number;
            zoom: number;
            angle: number;
            shear: number;
            border_handling: string;
            constant_color: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Load_Image_Sequence__mtb_ {
        /**
         * INPUT_TYPES: path, current_frame
         */
        inputs?: {
            path: string;
            current_frame: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Save_Image_Sequence__mtb_ {
        /**
         * INPUT_TYPES: images, filename_prefix, current_frame
         */
        inputs?: {
            images: unknown;
            filename_prefix: string;
            current_frame: number;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface Load_Vit_Matte_Model__mtb_ {
        /**
         * INPUT_TYPES: kind, autodownload
         */
        inputs?: {
            kind: string;
            autodownload: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: VITMATTE_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Generate_Trimap__mtb_ {
        /**
         * INPUT_TYPES: mask, erode, dilate
         */
        inputs?: {
            mask: unknown;
            erode: number;
            dilate: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Apply_Vit_Matte__mtb_ {
        /**
         * INPUT_TYPES: model, image, trimap, returns
         */
        inputs?: {
            model: unknown;
            image: unknown;
            trimap: unknown;
            returns: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface TimestepKeyframe {
        /**
         * INPUT_TYPES: start_percent
         */
        inputs?: {
            start_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: TIMESTEP_KEYFRAME
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_TimestepKeyframeInterpolation {
        /**
         * INPUT_TYPES: start_percent, end_percent, strength_start, strength_end, interpolation, intervals
         */
        inputs?: {
            start_percent: number;
            end_percent: number;
            strength_start: number;
            strength_end: number;
            interpolation: string;
            intervals: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: TIMESTEP_KEYFRAME
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_TimestepKeyframeFromStrengthList {
        /**
         * INPUT_TYPES: float_strengths, start_percent, end_percent
         */
        inputs?: {
            float_strengths: number;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: TIMESTEP_KEYFRAME
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentKeyframe {
        /**
         * INPUT_TYPES: batch_index, strength
         */
        inputs?: {
            batch_index: number;
            strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT_KEYFRAME
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentKeyframeTiming {
        /**
         * INPUT_TYPES: batch_index_from, batch_index_to_excl, strength_from, strength_to, interpolation
         */
        inputs?: {
            batch_index_from: number;
            batch_index_to_excl: number;
            strength_from: number;
            strength_to: number;
            interpolation: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT_KEYFRAME
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentKeyframeBatchedGroup {
        /**
         * INPUT_TYPES: float_strengths
         */
        inputs?: {
            float_strengths: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT_KEYFRAME
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LatentKeyframeGroup {
        /**
         * INPUT_TYPES: index_strengths
         */
        inputs?: {
            index_strengths: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT_KEYFRAME
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_AdvancedControlNetApply_v2 {
        /**
         * INPUT_TYPES: positive, negative, control_net, image, strength, start_percent, end_percent
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            control_net: unknown;
            image: unknown;
            strength: number;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ACN_AdvancedControlNetApplySingle_v2 {
        /**
         * INPUT_TYPES: conditioning, control_net, image, strength, start_percent, end_percent
         */
        inputs?: {
            conditioning: unknown;
            control_net: unknown;
            image: unknown;
            strength: number;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, MODEL
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ACN_ControlNetLoaderAdvanced {
        /**
         * INPUT_TYPES: cnet
         */
        inputs?: {
            cnet: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_DiffControlNetLoaderAdvanced {
        /**
         * INPUT_TYPES: model, cnet
         */
        inputs?: {
            model: unknown;
            cnet: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_ScaledSoftControlNetWeights {
        /**
         * INPUT_TYPES: base_multiplier
         */
        inputs?: {
            base_multiplier: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET_WEIGHTS, TIMESTEP_KEYFRAME
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ScaledSoftMaskedUniversalWeights {
        /**
         * INPUT_TYPES: mask, min_base_multiplier, max_base_multiplier
         */
        inputs?: {
            mask: unknown;
            min_base_multiplier: number;
            max_base_multiplier: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET_WEIGHTS, TIMESTEP_KEYFRAME
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ACN_SoftControlNetWeightsSD15 {
        /**
         * INPUT_TYPES: output_0, output_1, output_2, output_3, output_4, output_5, output_6, output_7, output_8, output_9, output_10, output_11, middle_0
         */
        inputs?: {
            output_0: number;
            output_1: number;
            output_2: number;
            output_3: number;
            output_4: number;
            output_5: number;
            output_6: number;
            output_7: number;
            output_8: number;
            output_9: number;
            output_10: number;
            output_11: number;
            middle_0: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET_WEIGHTS, TIMESTEP_KEYFRAME
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ACN_CustomControlNetWeightsSD15 {
        /**
         * INPUT_TYPES: output_0, output_1, output_2, output_3, output_4, output_5, output_6, output_7, output_8, output_9, output_10, output_11, middle_0
         */
        inputs?: {
            output_0: number;
            output_1: number;
            output_2: number;
            output_3: number;
            output_4: number;
            output_5: number;
            output_6: number;
            output_7: number;
            output_8: number;
            output_9: number;
            output_10: number;
            output_11: number;
            middle_0: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET_WEIGHTS, TIMESTEP_KEYFRAME
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ACN_CustomControlNetWeightsFlux {
        /**
         * INPUT_TYPES: input_0, input_1, input_2, input_3, input_4, input_5, input_6, input_7, input_8, input_9, input_10, input_11, input_12, input_13, input_14, input_15, input_16, input_17, input_18
         */
        inputs?: {
            input_0: number;
            input_1: number;
            input_2: number;
            input_3: number;
            input_4: number;
            input_5: number;
            input_6: number;
            input_7: number;
            input_8: number;
            input_9: number;
            input_10: number;
            input_11: number;
            input_12: number;
            input_13: number;
            input_14: number;
            input_15: number;
            input_16: number;
            input_17: number;
            input_18: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET_WEIGHTS, TIMESTEP_KEYFRAME
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ACN_SoftT2IAdapterWeights {
        /**
         * INPUT_TYPES: input_0, input_1, input_2, input_3
         */
        inputs?: {
            input_0: number;
            input_1: number;
            input_2: number;
            input_3: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET_WEIGHTS, TIMESTEP_KEYFRAME
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ACN_CustomT2IAdapterWeights {
        /**
         * INPUT_TYPES: input_0, input_1, input_2, input_3
         */
        inputs?: {
            input_0: number;
            input_1: number;
            input_2: number;
            input_3: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET_WEIGHTS, TIMESTEP_KEYFRAME
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ACN_DefaultUniversalWeights {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET_WEIGHTS, TIMESTEP_KEYFRAME
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ACN_ExtrasMiddleMult {
        /**
         * INPUT_TYPES: middle_mult
         */
        inputs?: {
            middle_mult: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CN_WEIGHTS_EXTRAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_SparseCtrlRGBPreprocessor {
        /**
         * INPUT_TYPES: image, vae, latent_size
         */
        inputs?: {
            image: unknown;
            vae: unknown;
            latent_size: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_SparseCtrlLoaderAdvanced {
        /**
         * INPUT_TYPES: sparsectrl_name, use_motion, motion_strength, motion_scale
         */
        inputs?: {
            sparsectrl_name: string;
            use_motion: unknown;
            motion_strength: number;
            motion_scale: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_SparseCtrlMergedLoaderAdvanced {
        /**
         * INPUT_TYPES: sparsectrl_name, control_net_name, use_motion, motion_strength, motion_scale
         */
        inputs?: {
            sparsectrl_name: string;
            control_net_name: string;
            use_motion: unknown;
            motion_strength: number;
            motion_scale: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_SparseCtrlIndexMethodNode {
        /**
         * INPUT_TYPES: indexes
         */
        inputs?: {
            indexes: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SPARSE_METHOD
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_SparseCtrlSpreadMethodNode {
        /**
         * INPUT_TYPES: spread
         */
        inputs?: {
            spread: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SPARSE_METHOD
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_SparseCtrlWeightExtras {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CN_WEIGHTS_EXTRAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_ControlNet__LoaderSingle {
        /**
         * INPUT_TYPES: name, control_type
         */
        inputs?: {
            name: string;
            control_type: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_ControlNet__LoaderAdvanced {
        /**
         * INPUT_TYPES: plus_input, name
         */
        inputs?: {
            plus_input: unknown;
            name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ACN_ControlNet__InputNode {
        /**
         * INPUT_TYPES: image, control_type
         */
        inputs?: {
            image: unknown;
            control_type: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: PLUS_INPUT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_CtrLoRALoader {
        /**
         * INPUT_TYPES: base, lora
         */
        inputs?: {
            base: string;
            lora: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_ReferencePreprocessor {
        /**
         * INPUT_TYPES: image, vae, latent_size
         */
        inputs?: {
            image: unknown;
            vae: unknown;
            latent_size: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_ReferenceControlNet {
        /**
         * INPUT_TYPES: reference_type, style_fidelity, ref_weight
         */
        inputs?: {
            reference_type: string;
            style_fidelity: number;
            ref_weight: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ACN_ReferenceControlNetFinetune {
        /**
         * INPUT_TYPES: attn_style_fidelity, attn_ref_weight, attn_strength, adain_style_fidelity, adain_ref_weight, adain_strength
         */
        inputs?: {
            attn_style_fidelity: number;
            attn_ref_weight: number;
            attn_strength: number;
            adain_style_fidelity: number;
            adain_ref_weight: number;
            adain_strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LoadImagesFromDirectory {
        /**
         * INPUT_TYPES: directory
         */
        inputs?: {
            directory: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface ScaledSoftControlNetWeights {
        /**
         * INPUT_TYPES: base_multiplier, flip_weights
         */
        inputs?: {
            base_multiplier: number;
            flip_weights: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET_WEIGHTS, TIMESTEP_KEYFRAME
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface SoftControlNetWeights {
        /**
         * INPUT_TYPES: weight_00, weight_01, weight_02, weight_03, weight_04, weight_05, weight_06, weight_07, weight_08, weight_09, weight_10, weight_11, weight_12, flip_weights
         */
        inputs?: {
            weight_00: number;
            weight_01: number;
            weight_02: number;
            weight_03: number;
            weight_04: number;
            weight_05: number;
            weight_06: number;
            weight_07: number;
            weight_08: number;
            weight_09: number;
            weight_10: number;
            weight_11: number;
            weight_12: number;
            flip_weights: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET_WEIGHTS, TIMESTEP_KEYFRAME
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface CustomControlNetWeights {
        /**
         * INPUT_TYPES: weight_00, weight_01, weight_02, weight_03, weight_04, weight_05, weight_06, weight_07, weight_08, weight_09, weight_10, weight_11, weight_12, flip_weights
         */
        inputs?: {
            weight_00: number;
            weight_01: number;
            weight_02: number;
            weight_03: number;
            weight_04: number;
            weight_05: number;
            weight_06: number;
            weight_07: number;
            weight_08: number;
            weight_09: number;
            weight_10: number;
            weight_11: number;
            weight_12: number;
            flip_weights: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET_WEIGHTS, TIMESTEP_KEYFRAME
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface SoftT2IAdapterWeights {
        /**
         * INPUT_TYPES: weight_00, weight_01, weight_02, weight_03, flip_weights
         */
        inputs?: {
            weight_00: number;
            weight_01: number;
            weight_02: number;
            weight_03: number;
            flip_weights: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET_WEIGHTS, TIMESTEP_KEYFRAME
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface CustomT2IAdapterWeights {
        /**
         * INPUT_TYPES: weight_00, weight_01, weight_02, weight_03, flip_weights
         */
        inputs?: {
            weight_00: number;
            weight_01: number;
            weight_02: number;
            weight_03: number;
            flip_weights: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET_WEIGHTS, TIMESTEP_KEYFRAME
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ACN_AdvancedControlNetApply {
        /**
         * INPUT_TYPES: positive, negative, control_net, image, strength, start_percent, end_percent
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            control_net: unknown;
            image: unknown;
            strength: number;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, MODEL
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface ACN_AdvancedControlNetApplySingle {
        /**
         * INPUT_TYPES: conditioning, control_net, image, strength, start_percent, end_percent
         */
        inputs?: {
            conditioning: unknown;
            control_net: unknown;
            image: unknown;
            strength: number;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, MODEL
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ControlNetLoaderAdvanced {
        /**
         * INPUT_TYPES: control_net_name
         */
        inputs?: {
            control_net_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface DiffControlNetLoaderAdvanced {
        /**
         * INPUT_TYPES: model, control_net_name
         */
        inputs?: {
            model: unknown;
            control_net_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AnimateDiffLoRALoader {
        /**
         * INPUT_TYPES: name, strength
         */
        inputs?: {
            name: string;
            strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MOTION_LORA
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AnimateDiffSamplingSettings {
        /**
         * INPUT_TYPES: batch_offset, noise_type, seed_gen, seed_offset
         */
        inputs?: {
            batch_offset: number;
            noise_type: string;
            seed_gen: string;
            seed_offset: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAMPLE_SETTINGS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AnimateDiffKeyframe {
        /**
         * INPUT_TYPES: start_percent
         */
        inputs?: {
            start_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AD_KEYFRAMES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_MultivalDynamic {
        /**
         * INPUT_TYPES: float_val
         */
        inputs?: {
            float_val: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MULTIVAL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_MultivalDynamicFloatInput {
        /**
         * INPUT_TYPES: float_val
         */
        inputs?: {
            float_val: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MULTIVAL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_MultivalDynamicFloats {
        /**
         * INPUT_TYPES: floats
         */
        inputs?: {
            floats: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MULTIVAL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_MultivalScaledMask {
        /**
         * INPUT_TYPES: min_float_val, max_float_val, mask
         */
        inputs?: {
            min_float_val: number;
            max_float_val: number;
            mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MULTIVAL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_MultivalConvertToMask {
        /**
         * INPUT_TYPES: multival
         */
        inputs?: {
            multival: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_StandardStaticContextOptions {
        /**
         * INPUT_TYPES: context_length, context_overlap
         */
        inputs?: {
            context_length: number;
            context_overlap: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXT_OPTIONS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_StandardUniformContextOptions {
        /**
         * INPUT_TYPES: context_length, context_stride, context_overlap
         */
        inputs?: {
            context_length: number;
            context_stride: number;
            context_overlap: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXT_OPTIONS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_LoopedUniformContextOptions {
        /**
         * INPUT_TYPES: context_length, context_stride, context_overlap, closed_loop
         */
        inputs?: {
            context_length: number;
            context_stride: number;
            context_overlap: number;
            closed_loop: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXT_OPTIONS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ViewsOnlyContextOptions {
        /**
         * INPUT_TYPES: view_opts_req
         */
        inputs?: {
            view_opts_req: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXT_OPTIONS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_BatchedContextOptions {
        /**
         * INPUT_TYPES: context_length
         */
        inputs?: {
            context_length: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXT_OPTIONS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AnimateDiffUniformContextOptions {
        /**
         * INPUT_TYPES: context_length, context_stride, context_overlap, context_schedule, closed_loop
         */
        inputs?: {
            context_length: number;
            context_stride: number;
            context_overlap: number;
            context_schedule: string;
            closed_loop: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXT_OPTIONS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_VisualizeContextOptionsK {
        /**
         * INPUT_TYPES: model, sampler_name, scheduler
         */
        inputs?: {
            model: unknown;
            sampler_name: string;
            scheduler: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_VisualizeContextOptionsKAdv {
        /**
         * INPUT_TYPES: model, sampler_name, scheduler
         */
        inputs?: {
            model: unknown;
            sampler_name: string;
            scheduler: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_VisualizeContextOptionsSCustom {
        /**
         * INPUT_TYPES: model, sigmas
         */
        inputs?: {
            model: unknown;
            sigmas: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_StandardStaticViewOptions {
        /**
         * INPUT_TYPES: view_length, view_overlap
         */
        inputs?: {
            view_length: number;
            view_overlap: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: VIEW_OPTS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_StandardUniformViewOptions {
        /**
         * INPUT_TYPES: view_length, view_stride, view_overlap
         */
        inputs?: {
            view_length: number;
            view_stride: number;
            view_overlap: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: VIEW_OPTS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_LoopedUniformViewOptions {
        /**
         * INPUT_TYPES: view_length, view_stride, view_overlap, closed_loop
         */
        inputs?: {
            view_length: number;
            view_stride: number;
            view_overlap: number;
            closed_loop: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: VIEW_OPTS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ContextExtras_Set {
        /**
         * INPUT_TYPES: context_opts
         */
        inputs?: {
            context_opts: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXT_OPTIONS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ContextExtras_ContextRef {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXT_EXTRAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ContextExtras_ContextRef_ModeFirst {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXTREF_MODE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ContextExtras_ContextRef_ModeSliding {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXTREF_MODE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ContextExtras_ContextRef_ModeIndexes {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXTREF_MODE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ContextExtras_ContextRef_TuneAttn {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXTREF_TUNE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ContextExtras_ContextRef_TuneAttnAdain {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXTREF_TUNE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ContextExtras_ContextRef_Keyframe {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXTREF_KEYFRAME
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ContextExtras_ContextRef_KeyframeInterpolation {
        /**
         * INPUT_TYPES: start_percent, end_percent, mult_start, mult_end, interpolation, intervals, inherit_missing, print_keyframes
         */
        inputs?: {
            start_percent: number;
            end_percent: number;
            mult_start: number;
            mult_end: number;
            interpolation: string;
            intervals: number;
            inherit_missing: unknown;
            print_keyframes: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXTREF_KEYFRAME
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ContextExtras_ContextRef_KeyframeFromList {
        /**
         * INPUT_TYPES: mults_float, start_percent, end_percent, inherit_missing, print_keyframes
         */
        inputs?: {
            mults_float: number;
            start_percent: number;
            end_percent: number;
            inherit_missing: unknown;
            print_keyframes: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXTREF_KEYFRAME
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ContextExtras_NaiveReuse {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTEXT_EXTRAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ContextExtras_NaiveReuse_Keyframe {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NAIVEREUSE_KEYFRAME
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ContextExtras_NaiveReuse_KeyframeInterpolation {
        /**
         * INPUT_TYPES: start_percent, end_percent, mult_start, mult_end, interpolation, intervals, inherit_missing, print_keyframes
         */
        inputs?: {
            start_percent: number;
            end_percent: number;
            mult_start: number;
            mult_end: number;
            interpolation: string;
            intervals: number;
            inherit_missing: unknown;
            print_keyframes: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NAIVEREUSE_KEYFRAME
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ContextExtras_NaiveReuse_KeyframeFromList {
        /**
         * INPUT_TYPES: mults_float, start_percent, end_percent, inherit_missing, print_keyframes
         */
        inputs?: {
            mults_float: number;
            start_percent: number;
            end_percent: number;
            inherit_missing: unknown;
            print_keyframes: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NAIVEREUSE_KEYFRAME
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_IterationOptsDefault {
        /**
         * INPUT_TYPES: iterations
         */
        inputs?: {
            iterations: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: ITERATION_OPTS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_IterationOptsFreeInit {
        /**
         * INPUT_TYPES: iterations, filter, d_s, d_t, n_butterworth, sigma_step, apply_to_1st_iter, init_type
         */
        inputs?: {
            iterations: number;
            filter: string;
            d_s: number;
            d_t: number;
            n_butterworth: number;
            sigma_step: number;
            apply_to_1st_iter: unknown;
            init_type: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: ITERATION_OPTS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_RegisterLoraHook {
        /**
         * INPUT_TYPES: model, clip, lora_name, strength_model, strength_clip
         */
        inputs?: {
            model: unknown;
            clip: unknown;
            lora_name: string;
            strength_model: number;
            strength_clip: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, HOOKS
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface ADE_RegisterLoraHookModelOnly {
        /**
         * INPUT_TYPES: model, lora_name, strength_model
         */
        inputs?: {
            model: unknown;
            lora_name: string;
            strength_model: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, HOOKS
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ADE_RegisterModelAsLoraHook {
        /**
         * INPUT_TYPES: model, clip, ckpt_name, strength_model, strength_clip
         */
        inputs?: {
            model: unknown;
            clip: unknown;
            ckpt_name: string;
            strength_model: number;
            strength_clip: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, HOOKS
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface ADE_RegisterModelAsLoraHookModelOnly {
        /**
         * INPUT_TYPES: model, ckpt_name, strength_model
         */
        inputs?: {
            model: unknown;
            ckpt_name: string;
            strength_model: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, HOOKS
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ADE_CombineLoraHooks {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOKS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CombineLoraHooksFour {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOKS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CombineLoraHooksEight {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOKS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_SetLoraHookKeyframe {
        /**
         * INPUT_TYPES: lora_hook, hook_kf
         */
        inputs?: {
            lora_hook: unknown;
            hook_kf: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOKS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AttachLoraHookToCLIP {
        /**
         * INPUT_TYPES: clip, lora_hook
         */
        inputs?: {
            clip: unknown;
            lora_hook: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_LoraHookKeyframe {
        /**
         * INPUT_TYPES: strength_model, start_percent, guarantee_steps
         */
        inputs?: {
            strength_model: number;
            start_percent: number;
            guarantee_steps: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOK_KEYFRAMES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_LoraHookKeyframeInterpolation {
        /**
         * INPUT_TYPES: start_percent, end_percent, strength_start, strength_end, interpolation, intervals, print_keyframes
         */
        inputs?: {
            start_percent: number;
            end_percent: number;
            strength_start: number;
            strength_end: number;
            interpolation: string;
            intervals: number;
            print_keyframes: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOK_KEYFRAMES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_LoraHookKeyframeFromStrengthList {
        /**
         * INPUT_TYPES: strengths_float, start_percent, end_percent, print_keyframes
         */
        inputs?: {
            strengths_float: number;
            start_percent: number;
            end_percent: number;
            print_keyframes: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: HOOK_KEYFRAMES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AttachLoraHookToConditioning {
        /**
         * INPUT_TYPES: conditioning, lora_hook
         */
        inputs?: {
            conditioning: unknown;
            lora_hook: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_PairedConditioningSetMask {
        /**
         * INPUT_TYPES: positive_ADD, negative_ADD, strength, set_cond_area
         */
        inputs?: {
            positive_ADD: unknown;
            negative_ADD: unknown;
            strength: number;
            set_cond_area: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ADE_ConditioningSetMask {
        /**
         * INPUT_TYPES: cond_ADD, strength, set_cond_area
         */
        inputs?: {
            cond_ADD: unknown;
            strength: number;
            set_cond_area: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_PairedConditioningSetMaskAndCombine {
        /**
         * INPUT_TYPES: positive, negative, positive_ADD, negative_ADD, strength, set_cond_area
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            positive_ADD: unknown;
            negative_ADD: unknown;
            strength: number;
            set_cond_area: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ADE_ConditioningSetMaskAndCombine {
        /**
         * INPUT_TYPES: cond, cond_ADD, strength, set_cond_area
         */
        inputs?: {
            cond: unknown;
            cond_ADD: unknown;
            strength: number;
            set_cond_area: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_PairedConditioningSetUnmaskedAndCombine {
        /**
         * INPUT_TYPES: positive, negative, positive_DEFAULT, negative_DEFAULT
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            positive_DEFAULT: unknown;
            negative_DEFAULT: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ADE_ConditioningSetUnmaskedAndCombine {
        /**
         * INPUT_TYPES: cond, cond_DEFAULT
         */
        inputs?: {
            cond: unknown;
            cond_DEFAULT: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_PairedConditioningCombine {
        /**
         * INPUT_TYPES: positive_A, negative_A, positive_B, negative_B
         */
        inputs?: {
            positive_A: unknown;
            negative_A: unknown;
            positive_B: unknown;
            negative_B: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ADE_ConditioningCombine {
        /**
         * INPUT_TYPES: cond_A, cond_B
         */
        inputs?: {
            cond_A: unknown;
            cond_B: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_TimestepsConditioning {
        /**
         * INPUT_TYPES: start_percent, end_percent
         */
        inputs?: {
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: TIMESTEPS_RANGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_NoiseLayerAdd {
        /**
         * INPUT_TYPES: batch_offset, noise_type, seed_gen_override, seed_offset, noise_weight
         */
        inputs?: {
            batch_offset: number;
            noise_type: string;
            seed_gen_override: string;
            seed_offset: number;
            noise_weight: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NOISE_LAYERS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_NoiseLayerAddWeighted {
        /**
         * INPUT_TYPES: batch_offset, noise_type, seed_gen_override, seed_offset, noise_weight, balance_multiplier
         */
        inputs?: {
            batch_offset: number;
            noise_type: string;
            seed_gen_override: string;
            seed_offset: number;
            noise_weight: number;
            balance_multiplier: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NOISE_LAYERS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_NoiseLayerNormalizedSum {
        /**
         * INPUT_TYPES: batch_offset, noise_type, seed_gen_override, seed_offset, noise_weight
         */
        inputs?: {
            batch_offset: number;
            noise_type: string;
            seed_gen_override: string;
            seed_offset: number;
            noise_weight: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NOISE_LAYERS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_NoiseLayerReplace {
        /**
         * INPUT_TYPES: batch_offset, noise_type, seed_gen_override, seed_offset
         */
        inputs?: {
            batch_offset: number;
            noise_type: string;
            seed_gen_override: string;
            seed_offset: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NOISE_LAYERS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AnimateDiffSettings {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AD_SETTINGS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AdjustPESweetspotStretch {
        /**
         * INPUT_TYPES: sweetspot, new_sweetspot, print_adjustment
         */
        inputs?: {
            sweetspot: number;
            new_sweetspot: number;
            print_adjustment: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: PE_ADJUST
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AdjustPEFullStretch {
        /**
         * INPUT_TYPES: pe_stretch, print_adjustment
         */
        inputs?: {
            pe_stretch: number;
            print_adjustment: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: PE_ADJUST
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AdjustPEManual {
        /**
         * INPUT_TYPES: cap_initial_pe_length, interpolate_pe_to_length, initial_pe_idx_offset, final_pe_idx_offset, print_adjustment
         */
        inputs?: {
            cap_initial_pe_length: number;
            interpolate_pe_to_length: number;
            initial_pe_idx_offset: number;
            final_pe_idx_offset: number;
            print_adjustment: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: PE_ADJUST
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AdjustWeightAllAdd {
        /**
         * INPUT_TYPES: all_ADD, print_adjustment
         */
        inputs?: {
            all_ADD: number;
            print_adjustment: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: WEIGHT_ADJUST
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AdjustWeightAllMult {
        /**
         * INPUT_TYPES: all_MULT, print_adjustment
         */
        inputs?: {
            all_MULT: number;
            print_adjustment: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: WEIGHT_ADJUST
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AdjustWeightIndivAdd {
        /**
         * INPUT_TYPES: pe_ADD, attn_ADD, other_ADD, print_adjustment
         */
        inputs?: {
            pe_ADD: number;
            attn_ADD: number;
            other_ADD: number;
            print_adjustment: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: WEIGHT_ADJUST
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AdjustWeightIndivMult {
        /**
         * INPUT_TYPES: pe_MULT, attn_MULT, other_MULT, print_adjustment
         */
        inputs?: {
            pe_MULT: number;
            attn_MULT: number;
            other_MULT: number;
            print_adjustment: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: WEIGHT_ADJUST
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AdjustWeightIndivAttnAdd {
        /**
         * INPUT_TYPES: pe_ADD, attn_ADD, attn_q_ADD, attn_k_ADD, attn_v_ADD, attn_out_weight_ADD, attn_out_bias_ADD, other_ADD, print_adjustment
         */
        inputs?: {
            pe_ADD: number;
            attn_ADD: number;
            attn_q_ADD: number;
            attn_k_ADD: number;
            attn_v_ADD: number;
            attn_out_weight_ADD: number;
            attn_out_bias_ADD: number;
            other_ADD: number;
            print_adjustment: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: WEIGHT_ADJUST
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AdjustWeightIndivAttnMult {
        /**
         * INPUT_TYPES: pe_MULT, attn_MULT, attn_q_MULT, attn_k_MULT, attn_v_MULT, attn_out_weight_MULT, attn_out_bias_MULT, other_MULT, print_adjustment
         */
        inputs?: {
            pe_MULT: number;
            attn_MULT: number;
            attn_q_MULT: number;
            attn_k_MULT: number;
            attn_v_MULT: number;
            attn_out_weight_MULT: number;
            attn_out_bias_MULT: number;
            other_MULT: number;
            print_adjustment: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: WEIGHT_ADJUST
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CustomCFGSimple {
        /**
         * INPUT_TYPES: cfg
         */
        inputs?: {
            cfg: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CUSTOM_CFG
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CustomCFG {
        /**
         * INPUT_TYPES: cfg_multival
         */
        inputs?: {
            cfg_multival: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CUSTOM_CFG
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CustomCFGKeyframeSimple {
        /**
         * INPUT_TYPES: cfg, start_percent, guarantee_steps
         */
        inputs?: {
            cfg: number;
            start_percent: number;
            guarantee_steps: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CUSTOM_CFG
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CustomCFGKeyframe {
        /**
         * INPUT_TYPES: cfg_multival, start_percent, guarantee_steps
         */
        inputs?: {
            cfg_multival: unknown;
            start_percent: number;
            guarantee_steps: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CUSTOM_CFG
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CustomCFGKeyframeInterpolation {
        /**
         * INPUT_TYPES: start_percent, end_percent, cfg_start, cfg_end, interpolation, intervals, print_keyframes
         */
        inputs?: {
            start_percent: number;
            end_percent: number;
            cfg_start: number;
            cfg_end: number;
            interpolation: string;
            intervals: number;
            print_keyframes: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CUSTOM_CFG
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CustomCFGKeyframeFromList {
        /**
         * INPUT_TYPES: cfgs_float, start_percent, end_percent, print_keyframes
         */
        inputs?: {
            cfgs_float: number;
            start_percent: number;
            end_percent: number;
            print_keyframes: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CUSTOM_CFG
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CFGExtrasPAGSimple {
        /**
         * INPUT_TYPES: scale
         */
        inputs?: {
            scale: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CFG_EXTRAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CFGExtrasPAG {
        /**
         * INPUT_TYPES: scale_multival
         */
        inputs?: {
            scale_multival: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CFG_EXTRAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CFGExtrasRescaleCFGSimple {
        /**
         * INPUT_TYPES: multiplier
         */
        inputs?: {
            multiplier: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CFG_EXTRAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CFGExtrasRescaleCFG {
        /**
         * INPUT_TYPES: mult_multival
         */
        inputs?: {
            mult_multival: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CFG_EXTRAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_SigmaSchedule {
        /**
         * INPUT_TYPES: beta_schedule
         */
        inputs?: {
            beta_schedule: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMA_SCHEDULE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_RawSigmaSchedule {
        /**
         * INPUT_TYPES: raw_beta_schedule, linear_start, linear_end, sampling, lcm_original_timesteps, zsnr
         */
        inputs?: {
            raw_beta_schedule: string;
            linear_start: number;
            linear_end: number;
            sampling: string;
            lcm_original_timesteps: number;
            zsnr: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMA_SCHEDULE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_SigmaScheduleWeightedAverage {
        /**
         * INPUT_TYPES: schedule_A, schedule_B, weight_A
         */
        inputs?: {
            schedule_A: unknown;
            schedule_B: unknown;
            weight_A: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMA_SCHEDULE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_SigmaScheduleWeightedAverageInterp {
        /**
         * INPUT_TYPES: schedule_A, schedule_B, weight_A_Start, weight_A_End, interpolation
         */
        inputs?: {
            schedule_A: unknown;
            schedule_B: unknown;
            weight_A_Start: number;
            weight_A_End: number;
            interpolation: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMA_SCHEDULE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_SigmaScheduleSplitAndCombine {
        /**
         * INPUT_TYPES: schedule_Start, schedule_End, idx_split_percent
         */
        inputs?: {
            schedule_Start: unknown;
            schedule_End: unknown;
            idx_split_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMA_SCHEDULE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_SigmaScheduleToSigmas {
        /**
         * INPUT_TYPES: sigma_schedule, scheduler, steps, denoise
         */
        inputs?: {
            sigma_schedule: unknown;
            scheduler: string;
            steps: number;
            denoise: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SIGMAS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_NoisedImageInjection {
        /**
         * INPUT_TYPES: image, vae
         */
        inputs?: {
            image: unknown;
            vae: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE_INJECT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_NoisedImageInjectOptions {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE_INJECT_OPTIONS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AncestralOptions {
        /**
         * INPUT_TYPES: noise_type, seed_offset
         */
        inputs?: {
            noise_type: string;
            seed_offset: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: ANCESTRAL_OPTS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_PromptScheduling {
        /**
         * INPUT_TYPES: prompts, clip
         */
        inputs?: {
            prompts: string;
            clip: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_PromptSchedulingLatents {
        /**
         * INPUT_TYPES: prompts, clip, latent
         */
        inputs?: {
            prompts: string;
            clip: unknown;
            latent: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ADE_ValueScheduling {
        /**
         * INPUT_TYPES: values
         */
        inputs?: {
            values: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT, FLOATS, INT, INTS
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface ADE_ValueSchedulingLatents {
        /**
         * INPUT_TYPES: values, latent
         */
        inputs?: {
            values: string;
            latent: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT, FLOATS, INT, INTS
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface ADE_ValuesReplace {
        /**
         * INPUT_TYPES: value_key, floats
         */
        inputs?: {
            value_key: string;
            floats: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: VALUES_REPLACE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_FloatToFloats {
        /**
         * INPUT_TYPES: FLOAT
         */
        inputs?: {
            FLOAT: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOATS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ADBlockCombo {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AD_BLOCK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ADBlockIndiv {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AD_BLOCK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_PerBlockHighLevel {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: PER_BLOCK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_PerBlock_SD15_MidLevel {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: PER_BLOCK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_PerBlock_SD15_LowLevel {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: PER_BLOCK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_PerBlock_SD15_FromFloats {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: PER_BLOCK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_PerBlock_SDXL_MidLevel {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: PER_BLOCK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_PerBlock_SDXL_LowLevel {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: PER_BLOCK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_PerBlock_SDXL_FromFloats {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: PER_BLOCK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AnimateDiffUnload {
        /**
         * INPUT_TYPES: model
         */
        inputs?: {
            model: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_EmptyLatentImageLarge {
        /**
         * INPUT_TYPES: width, height, batch_size
         */
        inputs?: {
            width: number;
            height: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CheckpointLoaderSimpleWithNoiseSelect {
        /**
         * INPUT_TYPES: ckpt_name, beta_schedule
         */
        inputs?: {
            ckpt_name: string;
            beta_schedule: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, VAE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface ADE_PerturbedAttentionGuidanceMultival {
        /**
         * INPUT_TYPES: model, scale_multival
         */
        inputs?: {
            model: unknown;
            scale_multival: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_RescaleCFGMultival {
        /**
         * INPUT_TYPES: model, mult_multival
         */
        inputs?: {
            model: unknown;
            mult_multival: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AnimateDiffLoaderGen1 {
        /**
         * INPUT_TYPES: model, model_name, beta_schedule
         */
        inputs?: {
            model: unknown;
            model_name: string;
            beta_schedule: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_UseEvolvedSampling {
        /**
         * INPUT_TYPES: model, beta_schedule
         */
        inputs?: {
            model: unknown;
            beta_schedule: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ApplyAnimateDiffModelSimple {
        /**
         * INPUT_TYPES: motion_model
         */
        inputs?: {
            motion_model: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: M_MODELS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ApplyAnimateDiffModel {
        /**
         * INPUT_TYPES: motion_model, start_percent, end_percent
         */
        inputs?: {
            motion_model: unknown;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: M_MODELS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_LoadAnimateDiffModel {
        /**
         * INPUT_TYPES: model_name
         */
        inputs?: {
            model_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MOTION_MODEL_ADE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ApplyAnimateLCMI2VModel {
        /**
         * INPUT_TYPES: motion_model, ref_latent, ref_drift, apply_ref_when_disabled, start_percent, end_percent
         */
        inputs?: {
            motion_model: unknown;
            ref_latent: unknown;
            ref_drift: number;
            apply_ref_when_disabled: unknown;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: M_MODELS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_LoadAnimateLCMI2VModel {
        /**
         * INPUT_TYPES: model_name
         */
        inputs?: {
            model_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MOTION_MODEL_ADE, MOTION_MODEL_ADE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ADE_UpscaleAndVAEEncode {
        /**
         * INPUT_TYPES: image, vae, latent_size, scale_method, crop
         */
        inputs?: {
            image: unknown;
            vae: unknown;
            latent_size: unknown;
            scale_method: string;
            crop: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_InjectI2VIntoAnimateDiffModel {
        /**
         * INPUT_TYPES: model_name, motion_model
         */
        inputs?: {
            model_name: string;
            motion_model: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MOTION_MODEL_ADE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ApplyAnimateDiffModelWithCameraCtrl {
        /**
         * INPUT_TYPES: motion_model, cameractrl_poses, start_percent, end_percent
         */
        inputs?: {
            motion_model: unknown;
            cameractrl_poses: unknown;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: M_MODELS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_LoadAnimateDiffModelWithCameraCtrl {
        /**
         * INPUT_TYPES: model_name, camera_ctrl
         */
        inputs?: {
            model_name: string;
            camera_ctrl: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MOTION_MODEL_ADE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CameraCtrlAnimateDiffKeyframe {
        /**
         * INPUT_TYPES: start_percent
         */
        inputs?: {
            start_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AD_KEYFRAMES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_LoadCameraPoses {
        /**
         * INPUT_TYPES: pose_filename
         */
        inputs?: {
            pose_filename: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CAMERACTRL_POSES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_LoadCameraPosesFromPath {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CAMERACTRL_POSES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CameraPoseBasic {
        /**
         * INPUT_TYPES: motion_type, speed, frame_length
         */
        inputs?: {
            motion_type: string;
            speed: number;
            frame_length: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CAMERACTRL_POSES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CameraPoseCombo {
        /**
         * INPUT_TYPES: motion_type1, motion_type2, motion_type3, motion_type4, motion_type5, motion_type6, speed, frame_length
         */
        inputs?: {
            motion_type1: string;
            motion_type2: string;
            motion_type3: string;
            motion_type4: string;
            motion_type5: string;
            motion_type6: string;
            speed: number;
            frame_length: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CAMERACTRL_POSES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CameraPoseAdvanced {
        /**
         * INPUT_TYPES: motion_type1, strength1, motion_type2, strength2, motion_type3, strength3, motion_type4, strength4, motion_type5, strength5, motion_type6, strength6, speed, frame_length
         */
        inputs?: {
            motion_type1: string;
            strength1: number;
            motion_type2: string;
            strength2: number;
            motion_type3: string;
            strength3: number;
            motion_type4: string;
            strength4: number;
            motion_type5: string;
            strength5: number;
            motion_type6: string;
            strength6: number;
            speed: number;
            frame_length: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CAMERACTRL_POSES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_CameraManualPoseAppend {
        /**
         * INPUT_TYPES: poses_first, poses_last
         */
        inputs?: {
            poses_first: unknown;
            poses_last: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CAMERACTRL_POSES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ReplaceCameraParameters {
        /**
         * INPUT_TYPES: poses, fx, fy, cx, cy
         */
        inputs?: {
            poses: unknown;
            fx: number;
            fy: number;
            cx: number;
            cy: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CAMERACTRL_POSES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ReplaceOriginalPoseAspectRatio {
        /**
         * INPUT_TYPES: poses, orig_pose_width, orig_pose_height
         */
        inputs?: {
            poses: unknown;
            orig_pose_width: number;
            orig_pose_height: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CAMERACTRL_POSES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_ApplyAnimateDiffModelWithPIA {
        /**
         * INPUT_TYPES: motion_model, image, vae, start_percent, end_percent
         */
        inputs?: {
            motion_model: unknown;
            image: unknown;
            vae: unknown;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: M_MODELS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_InputPIA_Multival {
        /**
         * INPUT_TYPES: multival
         */
        inputs?: {
            multival: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: PIA_INPUT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_InputPIA_PaperPresets {
        /**
         * INPUT_TYPES: preset, batch_index
         */
        inputs?: {
            preset: string;
            batch_index: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: PIA_INPUT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_PIA_AnimateDiffKeyframe {
        /**
         * INPUT_TYPES: start_percent
         */
        inputs?: {
            start_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AD_KEYFRAMES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_InjectPIAIntoAnimateDiffModel {
        /**
         * INPUT_TYPES: model_name, motion_model
         */
        inputs?: {
            model_name: string;
            motion_model: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MOTION_MODEL_ADE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AnimateDiffLoaderWithContext {
        /**
         * INPUT_TYPES: model, model_name, beta_schedule
         */
        inputs?: {
            model: unknown;
            model_name: string;
            beta_schedule: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface AnimateDiffLoaderV1 {
        /**
         * INPUT_TYPES: model, latents, model_name, unlimited_area_hack, beta_schedule
         */
        inputs?: {
            model: unknown;
            latents: unknown;
            model_name: string;
            unlimited_area_hack: unknown;
            beta_schedule: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, LATENT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ADE_AnimateDiffLoaderV1Advanced {
        /**
         * INPUT_TYPES: model, latents, model_name, unlimited_area_hack, context_length, context_stride, context_overlap, context_schedule, closed_loop, beta_schedule
         */
        inputs?: {
            model: unknown;
            latents: unknown;
            model_name: string;
            unlimited_area_hack: unknown;
            context_length: number;
            context_stride: number;
            context_overlap: number;
            context_schedule: string;
            closed_loop: unknown;
            beta_schedule: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, LATENT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ADE_AnimateDiffCombine {
        /**
         * INPUT_TYPES: images, frame_rate, loop_count, filename_prefix, format, pingpong, save_image
         */
        inputs?: {
            images: unknown;
            frame_rate: number;
            loop_count: number;
            filename_prefix: string;
            format: string;
            pingpong: unknown;
            save_image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: GIF
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AnimateDiffModelSettings_Release {
        /**
         * INPUT_TYPES: min_motion_scale, max_motion_scale
         */
        inputs?: {
            min_motion_scale: number;
            max_motion_scale: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AD_SETTINGS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AnimateDiffModelSettingsSimple {
        /**
         * INPUT_TYPES: motion_pe_stretch
         */
        inputs?: {
            motion_pe_stretch: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AD_SETTINGS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AnimateDiffModelSettings {
        /**
         * INPUT_TYPES: pe_strength, attn_strength, other_strength, motion_pe_stretch, cap_initial_pe_length, interpolate_pe_to_length, initial_pe_idx_offset, final_pe_idx_offset
         */
        inputs?: {
            pe_strength: number;
            attn_strength: number;
            other_strength: number;
            motion_pe_stretch: number;
            cap_initial_pe_length: number;
            interpolate_pe_to_length: number;
            initial_pe_idx_offset: number;
            final_pe_idx_offset: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AD_SETTINGS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ADE_AnimateDiffModelSettingsAdvancedAttnStrengths {
        /**
         * INPUT_TYPES: pe_strength, attn_strength, attn_q_strength, attn_k_strength, attn_v_strength, attn_out_weight_strength, attn_out_bias_strength, other_strength, motion_pe_stretch, cap_initial_pe_length, interpolate_pe_to_length, initial_pe_idx_offset, final_pe_idx_offset
         */
        inputs?: {
            pe_strength: number;
            attn_strength: number;
            attn_q_strength: number;
            attn_k_strength: number;
            attn_v_strength: number;
            attn_out_weight_strength: number;
            attn_out_bias_strength: number;
            other_strength: number;
            motion_pe_stretch: number;
            cap_initial_pe_length: number;
            interpolate_pe_to_length: number;
            initial_pe_idx_offset: number;
            final_pe_idx_offset: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AD_SETTINGS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface AutoCropFaces {
        /**
         * INPUT_TYPES: image, number_of_faces, scale_factor, shift_factor, start_index, max_faces_per_image, aspect_ratio
         */
        inputs?: {
            image: unknown;
            number_of_faces: number;
            scale_factor: number;
            shift_factor: number;
            start_index: number;
            max_faces_per_image: number;
            aspect_ratio: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, CROP_DATA
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface CLIPSeg {
        /**
         * INPUT_TYPES: image, text
         */
        inputs?: {
            image: unknown;
            text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK, IMAGE, IMAGE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface CombineSegMasks {
        /**
         * INPUT_TYPES: input_image, mask_1, mask_2
         */
        inputs?: {
            input_image: unknown;
            mask_1: unknown;
            mask_2: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK, IMAGE, IMAGE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LoadDepthPro {
        /**
         * INPUT_TYPES: precision
         */
        inputs?: {
            precision: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: DEPTHPRO_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface RunDepthPro {
        /**
         * INPUT_TYPES: DEPTHPRO_MODEL, IMAGE, invert, gamma
         */
        inputs?: {
            DEPTHPRO_MODEL: unknown;
            IMAGE: unknown;
            invert: unknown;
            gamma: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, LIST, LIST, FLOAT
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface MZ_Flux1PartialLoad_Patch {
        /**
         * INPUT_TYPES: model, double_blocks_cuda_size, single_blocks_cuda_size
         */
        inputs?: {
            model: unknown;
            double_blocks_cuda_size: number;
            single_blocks_cuda_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MZ_Flux1CheckpointLoaderNF4_cpuDynOffload {
        /**
         * INPUT_TYPES: ckpt_name, double_blocks_cuda_size, single_blocks_cuda_size
         */
        inputs?: {
            ckpt_name: string;
            double_blocks_cuda_size: number;
            single_blocks_cuda_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, VAE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface MZ_Flux1CheckpointLoader_cpuDynOffload {
        /**
         * INPUT_TYPES: ckpt_name, double_blocks_cuda_size, single_blocks_cuda_size
         */
        inputs?: {
            ckpt_name: string;
            double_blocks_cuda_size: number;
            single_blocks_cuda_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, VAE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface MZ_Flux1UnetLoader_cpuDynOffload {
        /**
         * INPUT_TYPES: unet_name, weight_dtype, double_blocks_cuda_size, single_blocks_cuda_size
         */
        inputs?: {
            unet_name: string;
            weight_dtype: string;
            double_blocks_cuda_size: number;
            single_blocks_cuda_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface UnetLoaderGGUF {
        /**
         * INPUT_TYPES: unet_name
         */
        inputs?: {
            unet_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPLoaderGGUF {
        /**
         * INPUT_TYPES: clip_name, type
         */
        inputs?: {
            clip_name: string;
            type: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface DualCLIPLoaderGGUF {
        /**
         * INPUT_TYPES: clip_name1, clip_name2, type
         */
        inputs?: {
            clip_name1: string;
            clip_name2: string;
            type: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface TripleCLIPLoaderGGUF {
        /**
         * INPUT_TYPES: clip_name1, clip_name2, clip_name3
         */
        inputs?: {
            clip_name1: string;
            clip_name2: string;
            clip_name3: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface QuadrupleCLIPLoaderGGUF {
        /**
         * INPUT_TYPES: clip_name1, clip_name2, clip_name3, clip_name4
         */
        inputs?: {
            clip_name1: string;
            clip_name2: string;
            clip_name3: string;
            clip_name4: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface UnetLoaderGGUFAdvanced {
        /**
         * INPUT_TYPES: unet_name, dequant_dtype, patch_dtype, patch_on_device
         */
        inputs?: {
            unet_name: string;
            dequant_dtype: string;
            patch_dtype: string;
            patch_on_device: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface InpaintCropImproved {
        /**
         * INPUT_TYPES: image, downscale_algorithm, upscale_algorithm, preresize, preresize_mode, preresize_min_width, preresize_min_height, preresize_max_width, preresize_max_height, mask_fill_holes, mask_expand_pixels, mask_invert, mask_blend_pixels, mask_hipass_filter, extend_for_outpainting, extend_up_factor, extend_down_factor, extend_left_factor, extend_right_factor, context_from_mask_extend_factor, output_resize_to_target_size, output_target_width, output_target_height, output_padding
         */
        inputs?: {
            image: unknown;
            downscale_algorithm: string;
            upscale_algorithm: string;
            preresize: unknown;
            preresize_mode: string;
            preresize_min_width: number;
            preresize_min_height: number;
            preresize_max_width: number;
            preresize_max_height: number;
            mask_fill_holes: unknown;
            mask_expand_pixels: number;
            mask_invert: unknown;
            mask_blend_pixels: number;
            mask_hipass_filter: number;
            extend_for_outpainting: unknown;
            extend_up_factor: number;
            extend_down_factor: number;
            extend_left_factor: number;
            extend_right_factor: number;
            context_from_mask_extend_factor: number;
            output_resize_to_target_size: unknown;
            output_target_width: number;
            output_target_height: number;
            output_padding: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STITCHER, IMAGE, MASK
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface InpaintStitchImproved {
        /**
         * INPUT_TYPES: stitcher, inpainted_image
         */
        inputs?: {
            stitcher: unknown;
            inpainted_image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface InpaintCrop {
        /**
         * INPUT_TYPES: image, mask, context_expand_pixels, context_expand_factor, fill_mask_holes, blur_mask_pixels, invert_mask, blend_pixels, rescale_algorithm, mode, force_width, force_height, rescale_factor, min_width, min_height, max_width, max_height, padding
         */
        inputs?: {
            image: unknown;
            mask: unknown;
            context_expand_pixels: number;
            context_expand_factor: number;
            fill_mask_holes: unknown;
            blur_mask_pixels: number;
            invert_mask: unknown;
            blend_pixels: number;
            rescale_algorithm: string;
            mode: string;
            force_width: number;
            force_height: number;
            rescale_factor: number;
            min_width: number;
            min_height: number;
            max_width: number;
            max_height: number;
            padding: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STITCH, IMAGE, MASK
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface InpaintStitch {
        /**
         * INPUT_TYPES: stitch, inpainted_image, rescale_algorithm
         */
        inputs?: {
            stitch: unknown;
            inpainted_image: unknown;
            rescale_algorithm: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface InpaintExtendOutpaint {
        /**
         * INPUT_TYPES: image, mask, mode, expand_up_pixels, expand_up_factor, expand_down_pixels, expand_down_factor, expand_left_pixels, expand_left_factor, expand_right_pixels, expand_right_factor
         */
        inputs?: {
            image: unknown;
            mask: unknown;
            mode: string;
            expand_up_pixels: number;
            expand_up_factor: number;
            expand_down_pixels: number;
            expand_down_factor: number;
            expand_left_pixels: number;
            expand_left_factor: number;
            expand_right_pixels: number;
            expand_right_factor: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, MASK
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface InpaintResize {
        /**
         * INPUT_TYPES: image, mask, rescale_algorithm, mode, min_width, min_height, rescale_factor
         */
        inputs?: {
            image: unknown;
            mask: unknown;
            rescale_algorithm: string;
            mode: string;
            min_width: number;
            min_height: number;
            rescale_factor: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, MASK
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LoadLotusModel {
        /**
         * INPUT_TYPES: model
         */
        inputs?: {
            model: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LOTUSUNET
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LotusSampler {
        /**
         * INPUT_TYPES: lotus_unet, samples, seed, per_batch, keep_model_loaded
         */
        inputs?: {
            lotus_unet: unknown;
            samples: unknown;
            seed: number;
            per_batch: number;
            keep_model_loaded: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MarigoldModelLoader {
        /**
         * INPUT_TYPES: model
         */
        inputs?: {
            model: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MARIGOLDMODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MarigoldDepthEstimation_v2 {
        /**
         * INPUT_TYPES: marigold_model, image, seed, denoise_steps, ensemble_size, processing_resolution, scheduler, use_taesd_vae
         */
        inputs?: {
            marigold_model: unknown;
            image: unknown;
            seed: number;
            denoise_steps: number;
            ensemble_size: number;
            processing_resolution: number;
            scheduler: string;
            use_taesd_vae: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MarigoldDepthEstimation_v2_video {
        /**
         * INPUT_TYPES: marigold_model, images, seed, denoise_steps, processing_resolution, scheduler, blend_factor, use_taesd_vae
         */
        inputs?: {
            marigold_model: unknown;
            images: unknown;
            seed: number;
            denoise_steps: number;
            processing_resolution: number;
            scheduler: string;
            blend_factor: number;
            use_taesd_vae: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MarigoldDepthEstimation {
        /**
         * INPUT_TYPES: image, seed, denoise_steps, n_repeat, regularizer_strength, reduction_method, max_iter, tol, invert, keep_model_loaded, n_repeat_batch_size, use_fp16, scheduler, normalize
         */
        inputs?: {
            image: unknown;
            seed: number;
            denoise_steps: number;
            n_repeat: number;
            regularizer_strength: number;
            reduction_method: string;
            max_iter: number;
            tol: number;
            invert: unknown;
            keep_model_loaded: unknown;
            n_repeat_batch_size: number;
            use_fp16: unknown;
            scheduler: string;
            normalize: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MarigoldDepthEstimationVideo {
        /**
         * INPUT_TYPES: image, seed, first_frame_denoise_steps, first_frame_n_repeat, n_repeat_batch_size, invert, keep_model_loaded, scheduler, normalize, denoise_steps, flow_warping, flow_depth_mix, noise_ratio, dtype
         */
        inputs?: {
            image: unknown;
            seed: number;
            first_frame_denoise_steps: number;
            first_frame_n_repeat: number;
            n_repeat_batch_size: number;
            invert: unknown;
            keep_model_loaded: unknown;
            scheduler: string;
            normalize: unknown;
            denoise_steps: number;
            flow_warping: unknown;
            flow_depth_mix: number;
            noise_ratio: number;
            dtype: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ColorizeDepthmap {
        /**
         * INPUT_TYPES: image, colorize_method
         */
        inputs?: {
            image: unknown;
            colorize_method: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SaveImageOpenEXR {
        /**
         * INPUT_TYPES: images, filename_prefix
         */
        inputs?: {
            images: unknown;
            filename_prefix: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface RemapDepth {
        /**
         * INPUT_TYPES: image, min, max, clamp
         */
        inputs?: {
            image: unknown;
            min: number;
            max: number;
            clamp: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface NunchakuFluxDiTLoader {
        /**
         * INPUT_TYPES: model_path, cache_threshold, attention, cpu_offload, device_id, data_type
         */
        inputs?: {
            model_path: string;
            cache_threshold: number;
            attention: string;
            cpu_offload: string;
            device_id: number;
            data_type: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface NunchakuQwenImageDiTLoader {
        /**
         * INPUT_TYPES: model_name, cpu_offload
         */
        inputs?: {
            model_name: string;
            cpu_offload: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface NunchakuFluxLoraLoader {
        /**
         * INPUT_TYPES: model, lora_name, lora_strength
         */
        inputs?: {
            model: unknown;
            lora_name: string;
            lora_strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface NunchakuFluxLoraStack {
        /**
         * INPUT_TYPES: model
         */
        inputs?: {
            model: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface NunchakuTextEncoderLoader {
        /**
         * INPUT_TYPES: model_type, text_encoder1, text_encoder2, t5_min_length, use_4bit_t5, int4_model
         */
        inputs?: {
            model_type: string;
            text_encoder1: string;
            text_encoder2: string;
            t5_min_length: number;
            use_4bit_t5: string;
            int4_model: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface NunchakuTextEncoderLoaderV2 {
        /**
         * INPUT_TYPES: model_type, text_encoder1, text_encoder2, t5_min_length
         */
        inputs?: {
            model_type: string;
            text_encoder1: string;
            text_encoder2: string;
            t5_min_length: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface NunchakuDepthPreprocessor {
        /**
         * INPUT_TYPES: image, model_path
         */
        inputs?: {
            image: unknown;
            model_path: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface NunchakuPulidApply {
        /**
         * INPUT_TYPES: pulid, image, model, ip_weight
         */
        inputs?: {
            pulid: unknown;
            image: unknown;
            model: unknown;
            ip_weight: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface NunchakuPulidLoader {
        /**
         * INPUT_TYPES: model
         */
        inputs?: {
            model: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, PULID
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface NunchakuPuLIDLoaderV2 {
        /**
         * INPUT_TYPES: model, pulid_file, eva_clip_file, insight_face_provider
         */
        inputs?: {
            model: unknown;
            pulid_file: string;
            eva_clip_file: string;
            insight_face_provider: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, PULID_PIPELINE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface NunchakuFluxPuLIDApplyV2 {
        /**
         * INPUT_TYPES: model, pulid_pipline, image, weight, start_at, end_at
         */
        inputs?: {
            model: unknown;
            pulid_pipline: unknown;
            image: unknown;
            weight: number;
            start_at: number;
            end_at: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface NunchakuFluxIPAdapterApply {
        /**
         * INPUT_TYPES: model, ipadapter_pipeline, image, weight
         */
        inputs?: {
            model: unknown;
            ipadapter_pipeline: unknown;
            image: unknown;
            weight: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface NunchakuIPAdapterLoader {
        /**
         * INPUT_TYPES: model
         */
        inputs?: {
            model: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, IPADAPTER_PIPELINE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface NunchakuModelMerger {
        /**
         * INPUT_TYPES: model_folder, save_name
         */
        inputs?: {
            model_folder: string;
            save_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface NunchakuWheelInstaller {
        /**
         * INPUT_TYPES: source, version, dev_version_github, backend
         */
        inputs?: {
            source: string;
            version: string;
            dev_version_github: string;
            backend: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Robust_Video_Matting {
        /**
         * INPUT_TYPES: video_frames, backbone, fp16, bg_color, batch_size
         */
        inputs?: {
            video_frames: unknown;
            backbone: string;
            fp16: unknown;
            bg_color: string;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface BRIAAI_Matting {
        /**
         * INPUT_TYPES: video_frames, version, fp16, bg_color, batch_size
         */
        inputs?: {
            video_frames: unknown;
            version: string;
            fp16: unknown;
            bg_color: string;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Yoloworld_ModelLoader_Zho {
        /**
         * INPUT_TYPES: yolo_world_model
         */
        inputs?: {
            yolo_world_model: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: YOLOWORLDMODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ESAM_ModelLoader_Zho {
        /**
         * INPUT_TYPES: device
         */
        inputs?: {
            device: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: ESAMMODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Yoloworld_ESAM_Zho {
        /**
         * INPUT_TYPES: yolo_world_model, esam_model, image, categories, confidence_threshold, iou_threshold, box_thickness, text_thickness, text_scale, with_confidence, with_class_agnostic_nms, with_segmentation, mask_combined, mask_extracted, mask_extracted_index
         */
        inputs?: {
            yolo_world_model: unknown;
            esam_model: unknown;
            image: unknown;
            categories: string;
            confidence_threshold: number;
            iou_threshold: number;
            box_thickness: number;
            text_thickness: number;
            text_scale: number;
            with_confidence: unknown;
            with_class_agnostic_nms: unknown;
            with_segmentation: unknown;
            mask_combined: unknown;
            mask_extracted: unknown;
            mask_extracted_index: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Yoloworld_ESAM_DetectorProvider_Zho {
        /**
         * INPUT_TYPES: yolo_world_model, categories, iou_threshold, with_class_agnostic_nms
         */
        inputs?: {
            yolo_world_model: unknown;
            categories: string;
            iou_threshold: number;
            with_class_agnostic_nms: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BBOX_DETECTOR, SEGM_DETECTOR
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface AnimeFace_SemSegPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface AnyLineArtPreprocessor_aux {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface BinaryPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CannyEdgePreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ColorPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface DensePosePreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface DepthAnythingPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Zoe_DepthAnythingPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface DepthAnythingV2Preprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface DiffusionEdge_Preprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface DSINE_NormalMapPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface DWPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, POSE_KEYPOINT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface AnimalPosePreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, POSE_KEYPOINT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface HEDPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface FakeScribblePreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface InpaintPreprocessor {
        /**
         * INPUT_TYPES: image, mask
         */
        inputs?: {
            image: unknown;
            mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LeReS_DepthMapPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LineArtPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface AnimeLineArtPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LineartStandardPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Manga2Anime_LineArt_Preprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MediaPipe_FaceMeshPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MeshGraphormer_DepthMapPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface MeshGraphormer_ImpactDetector_DepthMapPreprocessor {
        /**
         * INPUT_TYPES: image, bbox_detector
         */
        inputs?: {
            image: unknown;
            bbox_detector: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Metric3D_DepthMapPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Metric3D_NormalMapPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MiDaS_NormalMapPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MiDaS_DepthMapPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface M_LSDPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface BAE_NormalMapPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface OneFormer_COCO_SemSegPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface OneFormer_ADE20K_SemSegPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface OpenposePreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, POSE_KEYPOINT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface PiDiNetPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SavePoseKpsAsJsonFile {
        /**
         * INPUT_TYPES: pose_kps, filename_prefix
         */
        inputs?: {
            pose_kps: unknown;
            filename_prefix: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface FacialPartColoringFromPoseKps {
        /**
         * INPUT_TYPES: pose_kps, mode, skin, left_eye, right_eye, nose, upper_lip, inner_mouth, lower_lip
         */
        inputs?: {
            pose_kps: unknown;
            mode: string;
            skin: string;
            left_eye: string;
            right_eye: string;
            nose: string;
            upper_lip: string;
            inner_mouth: string;
            lower_lip: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface UpperBodyTrackingFromPoseKps {
        /**
         * INPUT_TYPES: pose_kps, id_include, Head_width_height, Neck_width_height, Shoulder_width_height, Torso_width_height, RArm_width_height, RForearm_width_height, LArm_width_height, LForearm_width_height
         */
        inputs?: {
            pose_kps: unknown;
            id_include: string;
            Head_width_height: string;
            Neck_width_height: string;
            Shoulder_width_height: string;
            Torso_width_height: string;
            RArm_width_height: string;
            RForearm_width_height: string;
            LArm_width_height: string;
            LForearm_width_height: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: TRACKING, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface RenderPeopleKps {
        /**
         * INPUT_TYPES: kps, render_body, render_hand, render_face
         */
        inputs?: {
            kps: unknown;
            render_body: unknown;
            render_hand: unknown;
            render_face: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface RenderAnimalKps {
        /**
         * INPUT_TYPES: kps
         */
        inputs?: {
            kps: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PyraCannyPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageLuminanceDetector {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageIntensityDetector {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ScribblePreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Scribble_XDoG_Preprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Scribble_PiDiNet_Preprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SAMPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ShufflePreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface TEEDPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface TilePreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface TTPlanet_TileGF_Preprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface TTPlanet_TileSimple_Preprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface UniFormer_SemSegPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SemSegPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Unimatch_OptFlowPreprocessor {
        /**
         * INPUT_TYPES: image, ckpt_name, backward_flow, bidirectional_flow
         */
        inputs?: {
            image: unknown;
            ckpt_name: string;
            backward_flow: unknown;
            bidirectional_flow: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: OPTICAL_FLOW, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface MaskOptFlow {
        /**
         * INPUT_TYPES: optical_flow, mask
         */
        inputs?: {
            optical_flow: unknown;
            mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: OPTICAL_FLOW, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Zoe_DepthMapPreprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface AIO_Preprocessor {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ControlNetPreprocessorSelector {
        /**
         * INPUT_TYPES: preprocessor
         */
        inputs?: {
            preprocessor: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: ANY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PixelPerfectResolution {
        /**
         * INPUT_TYPES: original_image, image_gen_width, image_gen_height, resize_mode
         */
        inputs?: {
            original_image: unknown;
            image_gen_width: number;
            image_gen_height: number;
            resize_mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageGenResolutionFromImage {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, INT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ImageGenResolutionFromLatent {
        /**
         * INPUT_TYPES: latent
         */
        inputs?: {
            latent: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, INT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface HintImageEnchance {
        /**
         * INPUT_TYPES: hint_image, image_gen_width, image_gen_height, resize_mode
         */
        inputs?: {
            hint_image: unknown;
            image_gen_width: number;
            image_gen_height: number;
            resize_mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ExecuteAllControlNetPreprocessors {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ControlNetAuxSimpleAddText {
        /**
         * INPUT_TYPES: image, text
         */
        inputs?: {
            image: unknown;
            text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPTextEncodeSDXL_ {
        /**
         * INPUT_TYPES: width, height, size_cond_factor, text, clip
         */
        inputs?: {
            width: number;
            height: number;
            size_cond_factor: number;
            text: string;
            clip: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ConditioningCombineMultiple_ {
        /**
         * INPUT_TYPES: conditioning_1, conditioning_2
         */
        inputs?: {
            conditioning_1: unknown;
            conditioning_2: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SD3NegativeConditioning_ {
        /**
         * INPUT_TYPES: conditioning, end
         */
        inputs?: {
            conditioning: unknown;
            end: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface FluxAttentionSeeker_ {
        /**
         * INPUT_TYPES: clip, apply_to_query, apply_to_key, apply_to_value, apply_to_out, clip_l_0, clip_l_1, clip_l_2, clip_l_3, clip_l_4, clip_l_5, clip_l_6, clip_l_7, clip_l_8, clip_l_9, clip_l_10, clip_l_11, t5xxl_0, t5xxl_1, t5xxl_2, t5xxl_3, t5xxl_4, t5xxl_5, t5xxl_6, t5xxl_7, t5xxl_8, t5xxl_9, t5xxl_10, t5xxl_11, t5xxl_12, t5xxl_13, t5xxl_14, t5xxl_15, t5xxl_16, t5xxl_17, t5xxl_18, t5xxl_19, t5xxl_20, t5xxl_21, t5xxl_22, t5xxl_23
         */
        inputs?: {
            clip: unknown;
            apply_to_query: unknown;
            apply_to_key: unknown;
            apply_to_value: unknown;
            apply_to_out: unknown;
            clip_l_0: number;
            clip_l_1: number;
            clip_l_2: number;
            clip_l_3: number;
            clip_l_4: number;
            clip_l_5: number;
            clip_l_6: number;
            clip_l_7: number;
            clip_l_8: number;
            clip_l_9: number;
            clip_l_10: number;
            clip_l_11: number;
            t5xxl_0: number;
            t5xxl_1: number;
            t5xxl_2: number;
            t5xxl_3: number;
            t5xxl_4: number;
            t5xxl_5: number;
            t5xxl_6: number;
            t5xxl_7: number;
            t5xxl_8: number;
            t5xxl_9: number;
            t5xxl_10: number;
            t5xxl_11: number;
            t5xxl_12: number;
            t5xxl_13: number;
            t5xxl_14: number;
            t5xxl_15: number;
            t5xxl_16: number;
            t5xxl_17: number;
            t5xxl_18: number;
            t5xxl_19: number;
            t5xxl_20: number;
            t5xxl_21: number;
            t5xxl_22: number;
            t5xxl_23: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SD3AttentionSeekerLG_ {
        /**
         * INPUT_TYPES: clip, apply_to_query, apply_to_key, apply_to_value, apply_to_out, clip_l_0, clip_l_1, clip_l_2, clip_l_3, clip_l_4, clip_l_5, clip_l_6, clip_l_7, clip_l_8, clip_l_9, clip_l_10, clip_l_11, clip_g_0, clip_g_1, clip_g_2, clip_g_3, clip_g_4, clip_g_5, clip_g_6, clip_g_7, clip_g_8, clip_g_9, clip_g_10, clip_g_11, clip_g_12, clip_g_13, clip_g_14, clip_g_15, clip_g_16, clip_g_17, clip_g_18, clip_g_19, clip_g_20, clip_g_21, clip_g_22, clip_g_23, clip_g_24, clip_g_25, clip_g_26, clip_g_27, clip_g_28, clip_g_29, clip_g_30, clip_g_31
         */
        inputs?: {
            clip: unknown;
            apply_to_query: unknown;
            apply_to_key: unknown;
            apply_to_value: unknown;
            apply_to_out: unknown;
            clip_l_0: number;
            clip_l_1: number;
            clip_l_2: number;
            clip_l_3: number;
            clip_l_4: number;
            clip_l_5: number;
            clip_l_6: number;
            clip_l_7: number;
            clip_l_8: number;
            clip_l_9: number;
            clip_l_10: number;
            clip_l_11: number;
            clip_g_0: number;
            clip_g_1: number;
            clip_g_2: number;
            clip_g_3: number;
            clip_g_4: number;
            clip_g_5: number;
            clip_g_6: number;
            clip_g_7: number;
            clip_g_8: number;
            clip_g_9: number;
            clip_g_10: number;
            clip_g_11: number;
            clip_g_12: number;
            clip_g_13: number;
            clip_g_14: number;
            clip_g_15: number;
            clip_g_16: number;
            clip_g_17: number;
            clip_g_18: number;
            clip_g_19: number;
            clip_g_20: number;
            clip_g_21: number;
            clip_g_22: number;
            clip_g_23: number;
            clip_g_24: number;
            clip_g_25: number;
            clip_g_26: number;
            clip_g_27: number;
            clip_g_28: number;
            clip_g_29: number;
            clip_g_30: number;
            clip_g_31: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SD3AttentionSeekerT5_ {
        /**
         * INPUT_TYPES: clip, apply_to_query, apply_to_key, apply_to_value, apply_to_out, t5xxl_0, t5xxl_1, t5xxl_2, t5xxl_3, t5xxl_4, t5xxl_5, t5xxl_6, t5xxl_7, t5xxl_8, t5xxl_9, t5xxl_10, t5xxl_11, t5xxl_12, t5xxl_13, t5xxl_14, t5xxl_15, t5xxl_16, t5xxl_17, t5xxl_18, t5xxl_19, t5xxl_20, t5xxl_21, t5xxl_22, t5xxl_23
         */
        inputs?: {
            clip: unknown;
            apply_to_query: unknown;
            apply_to_key: unknown;
            apply_to_value: unknown;
            apply_to_out: unknown;
            t5xxl_0: number;
            t5xxl_1: number;
            t5xxl_2: number;
            t5xxl_3: number;
            t5xxl_4: number;
            t5xxl_5: number;
            t5xxl_6: number;
            t5xxl_7: number;
            t5xxl_8: number;
            t5xxl_9: number;
            t5xxl_10: number;
            t5xxl_11: number;
            t5xxl_12: number;
            t5xxl_13: number;
            t5xxl_14: number;
            t5xxl_15: number;
            t5xxl_16: number;
            t5xxl_17: number;
            t5xxl_18: number;
            t5xxl_19: number;
            t5xxl_20: number;
            t5xxl_21: number;
            t5xxl_22: number;
            t5xxl_23: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface FluxBlocksBuster_ {
        /**
         * INPUT_TYPES: model, blocks
         */
        inputs?: {
            model: unknown;
            blocks: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ImageEnhanceDifference_ {
        /**
         * INPUT_TYPES: image1, image2, exponent
         */
        inputs?: {
            image1: unknown;
            image2: unknown;
            exponent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageBatchMultiple_ {
        /**
         * INPUT_TYPES: image_1, method
         */
        inputs?: {
            image_1: unknown;
            method: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageExpandBatch_ {
        /**
         * INPUT_TYPES: image, size, method
         */
        inputs?: {
            image: unknown;
            size: number;
            method: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageFromBatch_ {
        /**
         * INPUT_TYPES: image, start, length
         */
        inputs?: {
            image: unknown;
            start: number;
            length: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageListToBatch_ {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageBatchToList_ {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageCompositeFromMaskBatch_ {
        /**
         * INPUT_TYPES: image_from, image_to, mask
         */
        inputs?: {
            image_from: unknown;
            image_to: unknown;
            mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageComposite_ {
        /**
         * INPUT_TYPES: destination, source, x, y, offset_x, offset_y
         */
        inputs?: {
            destination: unknown;
            source: unknown;
            x: number;
            y: number;
            offset_x: number;
            offset_y: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageCrop_ {
        /**
         * INPUT_TYPES: image, width, height, position, x_offset, y_offset
         */
        inputs?: {
            image: unknown;
            width: number;
            height: number;
            position: string;
            x_offset: number;
            y_offset: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, INT, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface ImageFlip_ {
        /**
         * INPUT_TYPES: image, axis
         */
        inputs?: {
            image: unknown;
            axis: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageRandomTransform_ {
        /**
         * INPUT_TYPES: image, seed, repeat, variation
         */
        inputs?: {
            image: unknown;
            seed: number;
            repeat: number;
            variation: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageRemoveAlpha_ {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageRemoveBackground_ {
        /**
         * INPUT_TYPES: rembg_session, image
         */
        inputs?: {
            rembg_session: unknown;
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface ImageResize_ {
        /**
         * INPUT_TYPES: image, width, height, interpolation, method, condition, multiple_of
         */
        inputs?: {
            image: unknown;
            width: number;
            height: number;
            interpolation: string;
            method: string;
            condition: string;
            multiple_of: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, INT, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface ImageSeamCarving_ {
        /**
         * INPUT_TYPES: image, width, height, energy, order
         */
        inputs?: {
            image: unknown;
            width: number;
            height: number;
            energy: string;
            order: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageTile_ {
        /**
         * INPUT_TYPES: image, rows, cols, overlap, overlap_x, overlap_y
         */
        inputs?: {
            image: unknown;
            rows: number;
            cols: number;
            overlap: number;
            overlap_x: number;
            overlap_y: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, INT, INT, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface ImageUntile_ {
        /**
         * INPUT_TYPES: tiles, overlap_x, overlap_y, rows, cols
         */
        inputs?: {
            tiles: unknown;
            overlap_x: number;
            overlap_y: number;
            rows: number;
            cols: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface RemBGSession_ {
        /**
         * INPUT_TYPES: model, providers
         */
        inputs?: {
            model: string;
            providers: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: REMBG_SESSION
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface TransparentBGSession_ {
        /**
         * INPUT_TYPES: mode, use_jit
         */
        inputs?: {
            mode: string;
            use_jit: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: REMBG_SESSION
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageApplyLUT_ {
        /**
         * INPUT_TYPES: image, lut_file, gamma_correction, clip_values, strength
         */
        inputs?: {
            image: unknown;
            lut_file: string;
            gamma_correction: unknown;
            clip_values: unknown;
            strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageCASharpening_ {
        /**
         * INPUT_TYPES: image, amount
         */
        inputs?: {
            image: unknown;
            amount: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageDesaturate_ {
        /**
         * INPUT_TYPES: image, factor, method
         */
        inputs?: {
            image: unknown;
            factor: number;
            method: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PixelOEPixelize_ {
        /**
         * INPUT_TYPES: image, downscale_mode, target_size, patch_size, thickness, color_matching, upscale
         */
        inputs?: {
            image: unknown;
            downscale_mode: string;
            target_size: number;
            patch_size: number;
            thickness: number;
            color_matching: unknown;
            upscale: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImagePosterize_ {
        /**
         * INPUT_TYPES: image, threshold
         */
        inputs?: {
            image: unknown;
            threshold: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageColorMatch_ {
        /**
         * INPUT_TYPES: image, reference, color_space, factor, device, batch_size
         */
        inputs?: {
            image: unknown;
            reference: unknown;
            color_space: string;
            factor: number;
            device: string;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageColorMatchAdobe_ {
        /**
         * INPUT_TYPES: image, reference, color_space, luminance_factor, color_intensity_factor, fade_factor, neutralization_factor, device
         */
        inputs?: {
            image: unknown;
            reference: unknown;
            color_space: string;
            luminance_factor: number;
            color_intensity_factor: number;
            fade_factor: number;
            neutralization_factor: number;
            device: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageHistogramMatch_ {
        /**
         * INPUT_TYPES: image, reference, method, factor, device
         */
        inputs?: {
            image: unknown;
            reference: unknown;
            method: string;
            factor: number;
            device: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImageSmartSharpen_ {
        /**
         * INPUT_TYPES: image, noise_radius, preserve_edges, sharpen, ratio
         */
        inputs?: {
            image: unknown;
            noise_radius: number;
            preserve_edges: number;
            sharpen: number;
            ratio: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface GetImageSize_ {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, INT, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface ImageToDevice_ {
        /**
         * INPUT_TYPES: image, device
         */
        inputs?: {
            image: unknown;
            device: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ImagePreviewFromLatent_ {
        /**
         * INPUT_TYPES: latent, vae, tile_size
         */
        inputs?: {
            latent: unknown;
            vae: unknown;
            tile_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface NoiseFromImage_ {
        /**
         * INPUT_TYPES: image, noise_strenght, noise_size, color_noise, mask_strength, mask_scale_diff, mask_contrast, saturation, contrast, blur
         */
        inputs?: {
            image: unknown;
            noise_strenght: number;
            noise_size: number;
            color_noise: number;
            mask_strength: number;
            mask_scale_diff: number;
            mask_contrast: number;
            saturation: number;
            contrast: number;
            blur: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MaskBlur_ {
        /**
         * INPUT_TYPES: mask, amount, device
         */
        inputs?: {
            mask: unknown;
            amount: number;
            device: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MaskBoundingBox_ {
        /**
         * INPUT_TYPES: mask, padding, blur
         */
        inputs?: {
            mask: unknown;
            padding: number;
            blur: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK, IMAGE, INT, INT, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface MaskFix_ {
        /**
         * INPUT_TYPES: mask, erode_dilate, fill_holes, remove_isolated_pixels, smooth, blur
         */
        inputs?: {
            mask: unknown;
            erode_dilate: number;
            fill_holes: number;
            remove_isolated_pixels: number;
            smooth: number;
            blur: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MaskFlip_ {
        /**
         * INPUT_TYPES: mask, axis
         */
        inputs?: {
            mask: unknown;
            axis: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MaskFromColor_ {
        /**
         * INPUT_TYPES: image, red, green, blue, threshold
         */
        inputs?: {
            image: unknown;
            red: number;
            green: number;
            blue: number;
            threshold: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MaskFromList_ {
        /**
         * INPUT_TYPES: width, height
         */
        inputs?: {
            width: number;
            height: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MaskFromRGBCMYBW_ {
        /**
         * INPUT_TYPES: image, threshold_r, threshold_g, threshold_b
         */
        inputs?: {
            image: unknown;
            threshold_r: number;
            threshold_g: number;
            threshold_b: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK, MASK, MASK, MASK, MASK, MASK, MASK, MASK
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface MaskFromSegmentation_ {
        /**
         * INPUT_TYPES: image, segments, remove_isolated_pixels, remove_small_masks, fill_holes
         */
        inputs?: {
            image: unknown;
            segments: number;
            remove_isolated_pixels: number;
            remove_small_masks: number;
            fill_holes: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MaskPreview_ {
        /**
         * INPUT_TYPES: mask
         */
        inputs?: {
            mask: unknown;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface MaskSmooth_ {
        /**
         * INPUT_TYPES: mask, amount
         */
        inputs?: {
            mask: unknown;
            amount: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface TransitionMask_ {
        /**
         * INPUT_TYPES: width, height, frames, start_frame, end_frame, transition_type, timing_function
         */
        inputs?: {
            width: number;
            height: number;
            frames: number;
            start_frame: number;
            end_frame: number;
            transition_type: string;
            timing_function: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MaskBatch_ {
        /**
         * INPUT_TYPES: mask1, mask2
         */
        inputs?: {
            mask1: unknown;
            mask2: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MaskExpandBatch_ {
        /**
         * INPUT_TYPES: mask, size, method
         */
        inputs?: {
            mask: unknown;
            size: number;
            method: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MaskFromBatch_ {
        /**
         * INPUT_TYPES: mask, start, length
         */
        inputs?: {
            mask: unknown;
            start: number;
            length: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface KSamplerVariationsStochastic_ {
        /**
         * INPUT_TYPES: model, latent_image, noise_seed, steps, cfg, sampler, scheduler, positive, negative, variation_seed, variation_strength, cfg_scale
         */
        inputs?: {
            model: unknown;
            latent_image: unknown;
            noise_seed: number;
            steps: number;
            cfg: number;
            sampler: string;
            scheduler: string;
            positive: unknown;
            negative: unknown;
            variation_seed: unknown;
            variation_strength: number;
            cfg_scale: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface KSamplerVariationsWithNoise_ {
        /**
         * INPUT_TYPES: model, latent_image, main_seed, steps, cfg, sampler_name, scheduler, positive, negative, variation_strength, variation_seed, denoise
         */
        inputs?: {
            model: unknown;
            latent_image: unknown;
            main_seed: unknown;
            steps: number;
            cfg: number;
            sampler_name: string;
            scheduler: string;
            positive: unknown;
            negative: unknown;
            variation_strength: number;
            variation_seed: unknown;
            denoise: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface InjectLatentNoise_ {
        /**
         * INPUT_TYPES: latent, noise_seed, noise_strength, normalize
         */
        inputs?: {
            latent: unknown;
            noise_seed: number;
            noise_strength: number;
            normalize: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface FluxSamplerParams_ {
        /**
         * INPUT_TYPES: model, conditioning, latent_image, seed, sampler, scheduler, steps, guidance, max_shift, base_shift, denoise
         */
        inputs?: {
            model: unknown;
            conditioning: unknown;
            latent_image: unknown;
            seed: string;
            sampler: string;
            scheduler: string;
            steps: string;
            guidance: string;
            max_shift: string;
            base_shift: string;
            denoise: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT, SAMPLER_PARAMS
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface GuidanceTimestepping_ {
        /**
         * INPUT_TYPES: model, value, start_at, end_at
         */
        inputs?: {
            model: unknown;
            value: number;
            start_at: number;
            end_at: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PlotParameters_ {
        /**
         * INPUT_TYPES: images, params, order_by, cols_value, cols_num, add_prompt, add_params
         */
        inputs?: {
            images: unknown;
            params: unknown;
            order_by: string;
            cols_value: string;
            cols_num: number;
            add_prompt: string;
            add_params: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface TextEncodeForSamplerParams_ {
        /**
         * INPUT_TYPES: text, clip
         */
        inputs?: {
            text: string;
            clip: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SamplerSelectHelper_ {
        /**
         * INPUT_TYPES: euler, euler_cfg_pp, euler_ancestral, euler_ancestral_cfg_pp, heun, heunpp2, dpm_2, dpm_2_ancestral, lms, dpm_fast, dpm_adaptive, dpmpp_2s_ancestral, dpmpp_2s_ancestral_cfg_pp, dpmpp_sde, dpmpp_sde_gpu, dpmpp_2m, dpmpp_2m_cfg_pp, dpmpp_2m_sde, dpmpp_2m_sde_gpu, dpmpp_2m_sde_heun, dpmpp_2m_sde_heun_gpu, dpmpp_3m_sde, dpmpp_3m_sde_gpu, ddpm, lcm, ipndm, ipndm_v, deis, res_multistep, res_multistep_cfg_pp, res_multistep_ancestral, res_multistep_ancestral_cfg_pp, gradient_estimation, gradient_estimation_cfg_pp, er_sde, seeds_2, seeds_3, sa_solver, sa_solver_pece, ddim, uni_pc, uni_pc_bh2
         */
        inputs?: {
            euler: unknown;
            euler_cfg_pp: unknown;
            euler_ancestral: unknown;
            euler_ancestral_cfg_pp: unknown;
            heun: unknown;
            heunpp2: unknown;
            dpm_2: unknown;
            dpm_2_ancestral: unknown;
            lms: unknown;
            dpm_fast: unknown;
            dpm_adaptive: unknown;
            dpmpp_2s_ancestral: unknown;
            dpmpp_2s_ancestral_cfg_pp: unknown;
            dpmpp_sde: unknown;
            dpmpp_sde_gpu: unknown;
            dpmpp_2m: unknown;
            dpmpp_2m_cfg_pp: unknown;
            dpmpp_2m_sde: unknown;
            dpmpp_2m_sde_gpu: unknown;
            dpmpp_2m_sde_heun: unknown;
            dpmpp_2m_sde_heun_gpu: unknown;
            dpmpp_3m_sde: unknown;
            dpmpp_3m_sde_gpu: unknown;
            ddpm: unknown;
            lcm: unknown;
            ipndm: unknown;
            ipndm_v: unknown;
            deis: unknown;
            res_multistep: unknown;
            res_multistep_cfg_pp: unknown;
            res_multistep_ancestral: unknown;
            res_multistep_ancestral_cfg_pp: unknown;
            gradient_estimation: unknown;
            gradient_estimation_cfg_pp: unknown;
            er_sde: unknown;
            seeds_2: unknown;
            seeds_3: unknown;
            sa_solver: unknown;
            sa_solver_pece: unknown;
            ddim: unknown;
            uni_pc: unknown;
            uni_pc_bh2: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SchedulerSelectHelper_ {
        /**
         * INPUT_TYPES: simple, sgm_uniform, karras, exponential, ddim_uniform, beta, normal, linear_quadratic, kl_optimal
         */
        inputs?: {
            simple: unknown;
            sgm_uniform: unknown;
            karras: unknown;
            exponential: unknown;
            ddim_uniform: unknown;
            beta: unknown;
            normal: unknown;
            linear_quadratic: unknown;
            kl_optimal: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LorasForFluxParams_ {
        /**
         * INPUT_TYPES: lora_1, strength_model_1
         */
        inputs?: {
            lora_1: string;
            strength_model_1: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LORA_PARAMS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelSamplingSD3Advanced_ {
        /**
         * INPUT_TYPES: model, shift, cut_off, shift_multiplier
         */
        inputs?: {
            model: unknown;
            shift: number;
            cut_off: number;
            shift_multiplier: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ApplyCLIPSeg_ {
        /**
         * INPUT_TYPES: clip_seg, image, prompt, threshold, smooth, dilate, blur
         */
        inputs?: {
            clip_seg: unknown;
            image: unknown;
            prompt: string;
            threshold: number;
            smooth: number;
            dilate: number;
            blur: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LoadCLIPSegModels_ {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP_SEG
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface DrawText_ {
        /**
         * INPUT_TYPES: text, font, size, color, background_color, shadow_distance, shadow_blur, shadow_color, horizontal_align, vertical_align, offset_x, offset_y, direction
         */
        inputs?: {
            text: string;
            font: string;
            size: number;
            color: string;
            background_color: string;
            shadow_distance: number;
            shadow_blur: number;
            shadow_color: string;
            horizontal_align: string;
            vertical_align: string;
            offset_x: number;
            offset_y: number;
            direction: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface BatchCount_ {
        /**
         * INPUT_TYPES: batch
         */
        inputs?: {
            batch: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ConsoleDebug_ {
        /**
         * INPUT_TYPES: value
         */
        inputs?: {
            value: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface DebugTensorShape_ {
        /**
         * INPUT_TYPES: tensor
         */
        inputs?: {
            tensor: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface DisplayAny {
        /**
         * INPUT_TYPES: input, mode
         */
        inputs?: {
            input: unknown;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ModelCompile_ {
        /**
         * INPUT_TYPES: model, fullgraph, dynamic, mode
         */
        inputs?: {
            model: unknown;
            fullgraph: unknown;
            dynamic: unknown;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface RemoveLatentMask_ {
        /**
         * INPUT_TYPES: samples
         */
        inputs?: {
            samples: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SDXLEmptyLatentSizePicker_ {
        /**
         * INPUT_TYPES: resolution, batch_size, width_override, height_override
         */
        inputs?: {
            resolution: string;
            batch_size: number;
            width_override: number;
            height_override: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT, INT, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface SimpleComparison_ {
        /**
         * INPUT_TYPES: a, b, comparison
         */
        inputs?: {
            a: string;
            b: string;
            comparison: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SimpleCondition_ {
        /**
         * INPUT_TYPES: evaluate, on_true
         */
        inputs?: {
            evaluate: string;
            on_true: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: *
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SimpleMath_ {
        /**
         * INPUT_TYPES: value
         */
        inputs?: {
            value: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, FLOAT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface SimpleMathDual_ {
        /**
         * INPUT_TYPES: value_1, value_2
         */
        inputs?: {
            value_1: string;
            value_2: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, FLOAT, INT, FLOAT
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface SimpleMathCondition_ {
        /**
         * INPUT_TYPES: evaluate, on_true, on_false
         */
        inputs?: {
            evaluate: string;
            on_true: string;
            on_false: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, FLOAT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface SimpleMathBoolean_ {
        /**
         * INPUT_TYPES: value
         */
        inputs?: {
            value: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SimpleMathFloat_ {
        /**
         * INPUT_TYPES: value
         */
        inputs?: {
            value: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SimpleMathInt_ {
        /**
         * INPUT_TYPES: value
         */
        inputs?: {
            value: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SimpleMathPercent_ {
        /**
         * INPUT_TYPES: value
         */
        inputs?: {
            value: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SimpleMathSlider_ {
        /**
         * INPUT_TYPES: value, min, max, rounding
         */
        inputs?: {
            value: number;
            min: number;
            max: number;
            rounding: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT, INT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface SimpleMathSliderLowRes_ {
        /**
         * INPUT_TYPES: value, min, max, rounding
         */
        inputs?: {
            value: number;
            min: number;
            max: number;
            rounding: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT, INT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface FaceEmbedDistance {
        /**
         * INPUT_TYPES: analysis_models, reference, image, similarity_metric, filter_thresh, filter_best, generate_image_overlay
         */
        inputs?: {
            analysis_models: unknown;
            reference: unknown;
            image: unknown;
            similarity_metric: string;
            filter_thresh: number;
            filter_best: number;
            generate_image_overlay: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, FLOAT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface FaceAnalysisModels {
        /**
         * INPUT_TYPES: library, provider
         */
        inputs?: {
            library: string;
            provider: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: ANALYSIS_MODELS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface FaceBoundingBox {
        /**
         * INPUT_TYPES: analysis_models, image, padding, padding_percent, index
         */
        inputs?: {
            analysis_models: unknown;
            image: unknown;
            padding: number;
            padding_percent: number;
            index: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, INT, INT, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface FaceAlign {
        /**
         * INPUT_TYPES: analysis_models, image_from
         */
        inputs?: {
            analysis_models: unknown;
            image_from: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface FaceSegmentation {
        /**
         * INPUT_TYPES: analysis_models, image, area, grow, grow_tapered, blur
         */
        inputs?: {
            analysis_models: unknown;
            image: unknown;
            area: string;
            grow: number;
            grow_tapered: unknown;
            blur: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK, IMAGE, MASK, IMAGE, INT, INT, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface FaceWarp {
        /**
         * INPUT_TYPES: analysis_models, image_from, image_to, keypoints, grow, blur
         */
        inputs?: {
            analysis_models: unknown;
            image_from: unknown;
            image_to: unknown;
            keypoints: string;
            grow: number;
            blur: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface IPAdapter {
        /**
         * INPUT_TYPES: model, ipadapter, image, weight, start_at, end_at, weight_type
         */
        inputs?: {
            model: unknown;
            ipadapter: unknown;
            image: unknown;
            weight: number;
            start_at: number;
            end_at: number;
            weight_type: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface IPAdapterAdvanced {
        /**
         * INPUT_TYPES: model, ipadapter, image, weight, weight_type, combine_embeds, start_at, end_at, embeds_scaling
         */
        inputs?: {
            model: unknown;
            ipadapter: unknown;
            image: unknown;
            weight: number;
            weight_type: string;
            combine_embeds: string;
            start_at: number;
            end_at: number;
            embeds_scaling: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface IPAdapterBatch {
        /**
         * INPUT_TYPES: model, ipadapter, image, weight, weight_type, start_at, end_at, embeds_scaling, encode_batch_size
         */
        inputs?: {
            model: unknown;
            ipadapter: unknown;
            image: unknown;
            weight: number;
            weight_type: string;
            start_at: number;
            end_at: number;
            embeds_scaling: string;
            encode_batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface IPAdapterFaceID {
        /**
         * INPUT_TYPES: model, ipadapter, image, weight, weight_faceidv2, weight_type, combine_embeds, start_at, end_at, embeds_scaling
         */
        inputs?: {
            model: unknown;
            ipadapter: unknown;
            image: unknown;
            weight: number;
            weight_faceidv2: number;
            weight_type: string;
            combine_embeds: string;
            start_at: number;
            end_at: number;
            embeds_scaling: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface IPAAdapterFaceIDBatch {
        /**
         * INPUT_TYPES: model, ipadapter, image, weight, weight_faceidv2, weight_type, combine_embeds, start_at, end_at, embeds_scaling
         */
        inputs?: {
            model: unknown;
            ipadapter: unknown;
            image: unknown;
            weight: number;
            weight_faceidv2: number;
            weight_type: string;
            combine_embeds: string;
            start_at: number;
            end_at: number;
            embeds_scaling: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface IPAdapterTiled {
        /**
         * INPUT_TYPES: model, ipadapter, image, weight, weight_type, combine_embeds, start_at, end_at, sharpening, embeds_scaling
         */
        inputs?: {
            model: unknown;
            ipadapter: unknown;
            image: unknown;
            weight: number;
            weight_type: string;
            combine_embeds: string;
            start_at: number;
            end_at: number;
            sharpening: number;
            embeds_scaling: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, IMAGE, MASK
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface IPAdapterTiledBatch {
        /**
         * INPUT_TYPES: model, ipadapter, image, weight, weight_type, start_at, end_at, sharpening, embeds_scaling, encode_batch_size
         */
        inputs?: {
            model: unknown;
            ipadapter: unknown;
            image: unknown;
            weight: number;
            weight_type: string;
            start_at: number;
            end_at: number;
            sharpening: number;
            embeds_scaling: string;
            encode_batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, IMAGE, MASK
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface IPAdapterEmbeds {
        /**
         * INPUT_TYPES: model, ipadapter, pos_embed, weight, weight_type, start_at, end_at, embeds_scaling
         */
        inputs?: {
            model: unknown;
            ipadapter: unknown;
            pos_embed: unknown;
            weight: number;
            weight_type: string;
            start_at: number;
            end_at: number;
            embeds_scaling: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface IPAdapterEmbedsBatch {
        /**
         * INPUT_TYPES: model, ipadapter, pos_embed, weight, weight_type, start_at, end_at, embeds_scaling
         */
        inputs?: {
            model: unknown;
            ipadapter: unknown;
            pos_embed: unknown;
            weight: number;
            weight_type: string;
            start_at: number;
            end_at: number;
            embeds_scaling: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface IPAdapterStyleComposition {
        /**
         * INPUT_TYPES: model, ipadapter, image_style, image_composition, weight_style, weight_composition, expand_style, combine_embeds, start_at, end_at, embeds_scaling
         */
        inputs?: {
            model: unknown;
            ipadapter: unknown;
            image_style: unknown;
            image_composition: unknown;
            weight_style: number;
            weight_composition: number;
            expand_style: unknown;
            combine_embeds: string;
            start_at: number;
            end_at: number;
            embeds_scaling: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface IPAdapterStyleCompositionBatch {
        /**
         * INPUT_TYPES: model, ipadapter, image_style, image_composition, weight_style, weight_composition, expand_style, start_at, end_at, embeds_scaling
         */
        inputs?: {
            model: unknown;
            ipadapter: unknown;
            image_style: unknown;
            image_composition: unknown;
            weight_style: number;
            weight_composition: number;
            expand_style: unknown;
            start_at: number;
            end_at: number;
            embeds_scaling: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface IPAdapterMS {
        /**
         * INPUT_TYPES: model, ipadapter, image, weight, weight_faceidv2, weight_type, combine_embeds, start_at, end_at, embeds_scaling, layer_weights
         */
        inputs?: {
            model: unknown;
            ipadapter: unknown;
            image: unknown;
            weight: number;
            weight_faceidv2: number;
            weight_type: string;
            combine_embeds: string;
            start_at: number;
            end_at: number;
            embeds_scaling: string;
            layer_weights: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface IPAdapterFromParams {
        /**
         * INPUT_TYPES: model, ipadapter, ipadapter_params, combine_embeds, embeds_scaling
         */
        inputs?: {
            model: unknown;
            ipadapter: unknown;
            ipadapter_params: unknown;
            combine_embeds: string;
            embeds_scaling: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface IPAdapterUnifiedLoader {
        /**
         * INPUT_TYPES: model, preset
         */
        inputs?: {
            model: unknown;
            preset: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, IPADAPTER
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface IPAdapterUnifiedLoaderFaceID {
        /**
         * INPUT_TYPES: model, preset, lora_strength, provider
         */
        inputs?: {
            model: unknown;
            preset: string;
            lora_strength: number;
            provider: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, IPADAPTER
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface IPAdapterModelLoader {
        /**
         * INPUT_TYPES: ipadapter_file
         */
        inputs?: {
            ipadapter_file: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IPADAPTER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface IPAdapterInsightFaceLoader {
        /**
         * INPUT_TYPES: provider
         */
        inputs?: {
            provider: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INSIGHTFACE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface IPAdapterUnifiedLoaderCommunity {
        /**
         * INPUT_TYPES: model, preset
         */
        inputs?: {
            model: unknown;
            preset: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, IPADAPTER
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface IPAdapterEncoder {
        /**
         * INPUT_TYPES: ipadapter, image, weight
         */
        inputs?: {
            ipadapter: unknown;
            image: unknown;
            weight: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: EMBEDS, EMBEDS
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface IPAdapterCombineEmbeds {
        /**
         * INPUT_TYPES: embed1, method
         */
        inputs?: {
            embed1: unknown;
            method: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: EMBEDS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface IPAdapterNoise {
        /**
         * INPUT_TYPES: type, strength, blur
         */
        inputs?: {
            type: string;
            strength: number;
            blur: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface PrepImageForClipVision {
        /**
         * INPUT_TYPES: image, interpolation, crop_position, sharpening
         */
        inputs?: {
            image: unknown;
            interpolation: string;
            crop_position: string;
            sharpening: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface IPAdapterSaveEmbeds {
        /**
         * INPUT_TYPES: embeds, filename_prefix
         */
        inputs?: {
            embeds: unknown;
            filename_prefix: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface IPAdapterLoadEmbeds {
        /**
         * INPUT_TYPES: embeds
         */
        inputs?: {
            embeds: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: EMBEDS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface IPAdapterWeights {
        /**
         * INPUT_TYPES: weights, timing, frames, start_frame, end_frame, add_starting_frames, add_ending_frames, method
         */
        inputs?: {
            weights: string;
            timing: string;
            frames: number;
            start_frame: number;
            end_frame: number;
            add_starting_frames: number;
            add_ending_frames: number;
            method: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT, FLOAT, INT, IMAGE, IMAGE, WEIGHTS_STRATEGY
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface IPAdapterCombineWeights {
        /**
         * INPUT_TYPES: weights_1, weights_2
         */
        inputs?: {
            weights_1: number;
            weights_2: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT, INT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface IPAdapterWeightsFromStrategy {
        /**
         * INPUT_TYPES: weights_strategy
         */
        inputs?: {
            weights_strategy: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT, FLOAT, INT, IMAGE, IMAGE, WEIGHTS_STRATEGY
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface IPAdapterPromptScheduleFromWeightsStrategy {
        /**
         * INPUT_TYPES: weights_strategy, prompt
         */
        inputs?: {
            weights_strategy: unknown;
            prompt: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface IPAdapterRegionalConditioning {
        /**
         * INPUT_TYPES: image, image_weight, prompt_weight, weight_type, start_at, end_at
         */
        inputs?: {
            image: unknown;
            image_weight: number;
            prompt_weight: number;
            weight_type: string;
            start_at: number;
            end_at: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IPADAPTER_PARAMS, CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface IPAdapterCombineParams {
        /**
         * INPUT_TYPES: params_1, params_2
         */
        inputs?: {
            params_1: unknown;
            params_2: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IPADAPTER_PARAMS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerFilter__AddGrain {
        /**
         * INPUT_TYPES: image, grain_power, grain_scale, grain_sat
         */
        inputs?: {
            image: unknown;
            grain_power: number;
            grain_scale: number;
            grain_sat: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__BatchSelector {
        /**
         * INPUT_TYPES: select
         */
        inputs?: {
            select: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__BenUltra {
        /**
         * INPUT_TYPES: ben_model, image, detail_method, detail_erode, detail_dilate, black_point, white_point, max_megapixels, process_detail
         */
        inputs?: {
            ben_model: unknown;
            image: unknown;
            detail_method: string;
            detail_erode: number;
            detail_dilate: number;
            black_point: number;
            white_point: number;
            max_megapixels: number;
            process_detail: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__LoadBenModel {
        /**
         * INPUT_TYPES: model, device
         */
        inputs?: {
            model: string;
            device: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BEN_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__BiRefNetUltra {
        /**
         * INPUT_TYPES: image, detail_method, detail_erode, detail_dilate, black_point, white_point, process_detail, device, max_megapixels
         */
        inputs?: {
            image: unknown;
            detail_method: string;
            detail_erode: number;
            detail_dilate: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            device: string;
            max_megapixels: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__BiRefNetUltraV2 {
        /**
         * INPUT_TYPES: image, birefnet_model, detail_method, detail_erode, detail_dilate, black_point, white_point, process_detail, device, max_megapixels
         */
        inputs?: {
            image: unknown;
            birefnet_model: unknown;
            detail_method: string;
            detail_erode: number;
            detail_dilate: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            device: string;
            max_megapixels: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__LoadBiRefNetModel {
        /**
         * INPUT_TYPES: model
         */
        inputs?: {
            model: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BIREFNET_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__LoadBiRefNetModelV2 {
        /**
         * INPUT_TYPES: version
         */
        inputs?: {
            version: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BIREFNET_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__BlendIf_Mask {
        /**
         * INPUT_TYPES: image, invert_mask, blend_if, black_point, black_range, white_point, white_range
         */
        inputs?: {
            image: unknown;
            invert_mask: unknown;
            blend_if: string;
            black_point: number;
            black_range: number;
            white_point: number;
            white_range: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerFilter__ChannelShake {
        /**
         * INPUT_TYPES: image, distance, angle, mode
         */
        inputs?: {
            image: unknown;
            distance: number;
            angle: number;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__CheckMask {
        /**
         * INPUT_TYPES: mask, white_point, area_percent
         */
        inputs?: {
            mask: unknown;
            white_point: number;
            area_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__CheckMaskV2 {
        /**
         * INPUT_TYPES: mask, method, white_point, area_percent
         */
        inputs?: {
            mask: unknown;
            method: string;
            white_point: number;
            area_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__ColorAdapter {
        /**
         * INPUT_TYPES: image, color_ref_image, opacity
         */
        inputs?: {
            image: unknown;
            color_ref_image: unknown;
            opacity: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__AutoAdjust {
        /**
         * INPUT_TYPES: image, strength, brightness, contrast, saturation, red, green, blue
         */
        inputs?: {
            image: unknown;
            strength: number;
            brightness: number;
            contrast: number;
            saturation: number;
            red: number;
            green: number;
            blue: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__AutoAdjustV2 {
        /**
         * INPUT_TYPES: image, strength, brightness, contrast, saturation, red, green, blue, mode
         */
        inputs?: {
            image: unknown;
            strength: number;
            brightness: number;
            contrast: number;
            saturation: number;
            red: number;
            green: number;
            blue: number;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__AutoBrightness {
        /**
         * INPUT_TYPES: image, strength, saturation
         */
        inputs?: {
            image: unknown;
            strength: number;
            saturation: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__Brightness___Contrast {
        /**
         * INPUT_TYPES: image, brightness, contrast, saturation
         */
        inputs?: {
            image: unknown;
            brightness: number;
            contrast: number;
            saturation: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__BrightnessContrastV2 {
        /**
         * INPUT_TYPES: image, brightness, contrast, saturation
         */
        inputs?: {
            image: unknown;
            brightness: number;
            contrast: number;
            saturation: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__ColorBalance {
        /**
         * INPUT_TYPES: image, cyan_red, magenta_green, yellow_blue
         */
        inputs?: {
            image: unknown;
            cyan_red: number;
            magenta_green: number;
            yellow_blue: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__ColorTemperature {
        /**
         * INPUT_TYPES: image, temperature
         */
        inputs?: {
            image: unknown;
            temperature: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__Exposure {
        /**
         * INPUT_TYPES: image, exposure
         */
        inputs?: {
            image: unknown;
            exposure: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__Gamma {
        /**
         * INPUT_TYPES: image, gamma
         */
        inputs?: {
            image: unknown;
            gamma: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__HSV {
        /**
         * INPUT_TYPES: image, H, S, V
         */
        inputs?: {
            image: unknown;
            H: number;
            S: number;
            V: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__LAB {
        /**
         * INPUT_TYPES: image, L, A, B
         */
        inputs?: {
            image: unknown;
            L: number;
            A: number;
            B: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__Levels {
        /**
         * INPUT_TYPES: image, channel, black_point, white_point, gray_point, output_black_point, output_white_point
         */
        inputs?: {
            image: unknown;
            channel: string;
            black_point: number;
            white_point: number;
            gray_point: number;
            output_black_point: number;
            output_white_point: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__LUT_Apply {
        /**
         * INPUT_TYPES: image, LUT, color_space, strength
         */
        inputs?: {
            image: unknown;
            LUT: string;
            color_space: string;
            strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__RGB {
        /**
         * INPUT_TYPES: image, R, G, B
         */
        inputs?: {
            image: unknown;
            R: number;
            G: number;
            B: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__Color_of_Shadow___Highlight {
        /**
         * INPUT_TYPES: image, shadow_brightness, shadow_saturation, shadow_hue, shadow_level_offset, shadow_range, highlight_brightness, highlight_saturation, highlight_hue, highlight_level_offset, highlight_range
         */
        inputs?: {
            image: unknown;
            shadow_brightness: number;
            shadow_saturation: number;
            shadow_hue: number;
            shadow_level_offset: number;
            shadow_range: number;
            highlight_brightness: number;
            highlight_saturation: number;
            highlight_hue: number;
            highlight_level_offset: number;
            highlight_range: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__ColorofShadowHighlightV2 {
        /**
         * INPUT_TYPES: image, shadow_brightness, shadow_saturation, shadow_hue, shadow_level_offset, shadow_range, highlight_brightness, highlight_saturation, highlight_hue, highlight_level_offset, highlight_range
         */
        inputs?: {
            image: unknown;
            shadow_brightness: number;
            shadow_saturation: number;
            shadow_hue: number;
            shadow_level_offset: number;
            shadow_range: number;
            highlight_brightness: number;
            highlight_saturation: number;
            highlight_hue: number;
            highlight_level_offset: number;
            highlight_range: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerColor__YUV {
        /**
         * INPUT_TYPES: image, Y, U, V
         */
        inputs?: {
            image: unknown;
            Y: number;
            U: number;
            V: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ColorImage {
        /**
         * INPUT_TYPES: width, height, color
         */
        inputs?: {
            width: number;
            height: number;
            color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ColorImage_V2 {
        /**
         * INPUT_TYPES: size, custom_width, custom_height, color
         */
        inputs?: {
            size: string;
            custom_width: number;
            custom_height: number;
            color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerFilter__ColorMap {
        /**
         * INPUT_TYPES: image, color_map, opacity
         */
        inputs?: {
            image: unknown;
            color_map: string;
            opacity: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ColorName {
        /**
         * INPUT_TYPES: color, palette
         */
        inputs?: {
            color: string;
            palette: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerStyle__ColorOverlay_V2 {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity, color
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerStyle__ColorOverlay {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity, color
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ColorPicker {
        /**
         * INPUT_TYPES: color, mode
         */
        inputs?: {
            color: unknown;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__GrayValue {
        /**
         * INPUT_TYPES: color_value
         */
        inputs?: {
            color_value: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, INT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__HSV_Value {
        /**
         * INPUT_TYPES: color_value
         */
        inputs?: {
            color_value: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, INT, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__RGB_Value {
        /**
         * INPUT_TYPES: color_value
         */
        inputs?: {
            color_value: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, INT, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__CreateGradientMask {
        /**
         * INPUT_TYPES: width, height, gradient_side, gradient_scale, gradient_offset, opacity
         */
        inputs?: {
            width: number;
            height: number;
            gradient_side: string;
            gradient_scale: number;
            gradient_offset: number;
            opacity: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__CropBoxResolve {
        /**
         * INPUT_TYPES: crop_box
         */
        inputs?: {
            crop_box: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, INT, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__CropByMask {
        /**
         * INPUT_TYPES: image, mask_for_crop, invert_mask, detect, top_reserve, bottom_reserve, left_reserve, right_reserve
         */
        inputs?: {
            image: unknown;
            mask_for_crop: unknown;
            invert_mask: unknown;
            detect: string;
            top_reserve: number;
            bottom_reserve: number;
            left_reserve: number;
            right_reserve: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, BOX, IMAGE
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__CropByMask_V2 {
        /**
         * INPUT_TYPES: image, mask, invert_mask, detect, top_reserve, bottom_reserve, left_reserve, right_reserve, round_to_multiple
         */
        inputs?: {
            image: unknown;
            mask: unknown;
            invert_mask: unknown;
            detect: string;
            top_reserve: number;
            bottom_reserve: number;
            left_reserve: number;
            right_reserve: number;
            round_to_multiple: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, BOX, IMAGE
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__QueueStop {
        /**
         * INPUT_TYPES: any, mode, stop
         */
        inputs?: {
            any: string;
            mode: string;
            stop: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: *
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__SwitchCase {
        /**
         * INPUT_TYPES: switch_condition, case_1, case_2, case_3, input_default
         */
        inputs?: {
            switch_condition: string;
            case_1: string;
            case_2: string;
            case_3: string;
            input_default: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: *
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__If_ {
        /**
         * INPUT_TYPES: if_condition, when_TRUE, when_FALSE
         */
        inputs?: {
            if_condition: string;
            when_TRUE: string;
            when_FALSE: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: *
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__StringCondition {
        /**
         * INPUT_TYPES: text, condition, sub_string
         */
        inputs?: {
            text: string;
            condition: string;
            sub_string: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__BooleanOperator {
        /**
         * INPUT_TYPES: a, b, operator
         */
        inputs?: {
            a: string;
            b: string;
            operator: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__NumberCalculator {
        /**
         * INPUT_TYPES: a, b, operator
         */
        inputs?: {
            a: string;
            b: string;
            operator: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, FLOAT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__BooleanOperatorV2 {
        /**
         * INPUT_TYPES: a_value, b_value, operator
         */
        inputs?: {
            a_value: string;
            b_value: string;
            operator: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__NumberCalculatorV2 {
        /**
         * INPUT_TYPES: a_value, b_value, operator
         */
        inputs?: {
            a_value: string;
            b_value: string;
            operator: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, FLOAT, STRING
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__TextBox {
        /**
         * INPUT_TYPES: text
         */
        inputs?: {
            text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__String {
        /**
         * INPUT_TYPES: string
         */
        inputs?: {
            string: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__Integer {
        /**
         * INPUT_TYPES: int_value
         */
        inputs?: {
            int_value: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__Float {
        /**
         * INPUT_TYPES: float_value
         */
        inputs?: {
            float_value: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__Boolean {
        /**
         * INPUT_TYPES: bool_value
         */
        inputs?: {
            bool_value: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__Seed {
        /**
         * INPUT_TYPES: seed
         */
        inputs?: {
            seed: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerStyle__DropShadow {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity, distance_x, distance_y, grow, blur, shadow_color
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            distance_x: number;
            distance_y: number;
            grow: number;
            blur: number;
            shadow_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerStyle__DropShadow_V2 {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity, distance_x, distance_y, grow, blur, shadow_color
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            distance_x: number;
            distance_y: number;
            grow: number;
            blur: number;
            shadow_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__EVFSAMUltra {
        /**
         * INPUT_TYPES: image, model, precision, load_in_bit, prompt, detail_method, detail_erode, detail_dilate, black_point, white_point, process_detail, device, max_megapixels
         */
        inputs?: {
            image: unknown;
            model: string;
            precision: string;
            load_in_bit: string;
            prompt: string;
            detail_method: string;
            detail_erode: number;
            detail_dilate: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            device: string;
            max_megapixels: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ExtendCanvas {
        /**
         * INPUT_TYPES: image, invert_mask, top, bottom, left, right, color
         */
        inputs?: {
            image: unknown;
            invert_mask: unknown;
            top: number;
            bottom: number;
            left: number;
            right: number;
            color: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ExtendCanvasV2 {
        /**
         * INPUT_TYPES: image, invert_mask, top, bottom, left, right, color
         */
        inputs?: {
            image: unknown;
            invert_mask: unknown;
            top: number;
            bottom: number;
            left: number;
            right: number;
            color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerFilter__Film {
        /**
         * INPUT_TYPES: image, center_x, center_y, saturation, vignette_intensity, grain_power, grain_scale, grain_sat, grain_shadows, grain_highs, blur_strength, blur_focus_spread, focal_depth
         */
        inputs?: {
            image: unknown;
            center_x: number;
            center_y: number;
            saturation: number;
            vignette_intensity: number;
            grain_power: number;
            grain_scale: number;
            grain_sat: number;
            grain_shadows: number;
            grain_highs: number;
            blur_strength: number;
            blur_focus_spread: number;
            focal_depth: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerFilter__FilmV2 {
        /**
         * INPUT_TYPES: image, center_x, center_y, saturation, vignette_intensity, grain_method, grain_power, grain_scale, grain_sat, filmgrainer_shadows, filmgrainer_highs, blur_strength, blur_focus_spread, focal_depth
         */
        inputs?: {
            image: unknown;
            center_x: number;
            center_y: number;
            saturation: number;
            vignette_intensity: number;
            grain_method: string;
            grain_power: number;
            grain_scale: number;
            grain_sat: number;
            filmgrainer_shadows: number;
            filmgrainer_highs: number;
            blur_strength: number;
            blur_focus_spread: number;
            focal_depth: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__Florence2Ultra {
        /**
         * INPUT_TYPES: florence2_model, image, task, text_input, detail_method, detail_erode, detail_dilate, black_point, white_point, process_detail, device, max_megapixels
         */
        inputs?: {
            florence2_model: unknown;
            image: unknown;
            task: string;
            text_input: string;
            detail_method: string;
            detail_erode: number;
            detail_dilate: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            device: string;
            max_megapixels: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__LoadFlorence2Model {
        /**
         * INPUT_TYPES: version
         */
        inputs?: {
            version: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLORENCE2
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__Florence2Image2Prompt {
        /**
         * INPUT_TYPES: florence2_model, image, task, text_input, max_new_tokens, num_beams, do_sample, fill_mask
         */
        inputs?: {
            florence2_model: unknown;
            image: unknown;
            task: string;
            text_input: string;
            max_new_tokens: number;
            num_beams: number;
            do_sample: unknown;
            fill_mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerFilter__GaussianBlur {
        /**
         * INPUT_TYPES: image, blur
         */
        inputs?: {
            image: unknown;
            blur: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerFilter__GaussianBlurV2 {
        /**
         * INPUT_TYPES: image, blur
         */
        inputs?: {
            image: unknown;
            blur: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__GetColorTone {
        /**
         * INPUT_TYPES: image, mode
         */
        inputs?: {
            image: unknown;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, LIST
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__GetColorToneV2 {
        /**
         * INPUT_TYPES: image, mode, color_of, remove_bkgd_method, invert_mask, mask_grow
         */
        inputs?: {
            image: unknown;
            mode: string;
            color_of: string;
            remove_bkgd_method: string;
            invert_mask: unknown;
            mask_grow: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, STRING, LIST, MASK
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__GetImageSize {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, INT, BOX
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__GetMainColors {
        /**
         * INPUT_TYPES: image, k_means_algorithm
         */
        inputs?: {
            image: unknown;
            k_means_algorithm: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, STRING, STRING, STRING, STRING, STRING
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__GradientImage {
        /**
         * INPUT_TYPES: width, height, angle, start_color, end_color
         */
        inputs?: {
            width: number;
            height: number;
            angle: number;
            start_color: string;
            end_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__GradientImage_V2 {
        /**
         * INPUT_TYPES: size, custom_width, custom_height, angle, start_color, end_color
         */
        inputs?: {
            size: string;
            custom_width: number;
            custom_height: number;
            angle: number;
            start_color: string;
            end_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerStyle__Gradient_Map {
        /**
         * INPUT_TYPES: image, start_color, mid_color, end_color, mid_point, opacity
         */
        inputs?: {
            image: unknown;
            start_color: string;
            mid_color: string;
            end_color: string;
            mid_point: number;
            opacity: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerStyle__GradientOverlay {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity, start_color, start_alpha, end_color, end_alpha, angle
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            start_color: string;
            start_alpha: number;
            end_color: string;
            end_alpha: number;
            angle: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerStyle__GradientOverlay_V2 {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity, start_color, start_alpha, end_color, end_alpha, angle
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            start_color: string;
            start_alpha: number;
            end_color: string;
            end_alpha: number;
            angle: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerFilter__HDREffects {
        /**
         * INPUT_TYPES: image, hdr_intensity, shadow_intensity, highlight_intensity, gamma_intensity, contrast, enhance_color
         */
        inputs?: {
            image: unknown;
            hdr_intensity: number;
            shadow_intensity: number;
            highlight_intensity: number;
            gamma_intensity: number;
            contrast: number;
            enhance_color: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__HLFrequencyDetailRestore {
        /**
         * INPUT_TYPES: image, detail_image, keep_high_freq, erase_low_freq, mask_blur
         */
        inputs?: {
            image: unknown;
            detail_image: unknown;
            keep_high_freq: number;
            erase_low_freq: number;
            mask_blur: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__HumanPartsUltra {
        /**
         * INPUT_TYPES: image, face, hair, glasses, top_clothes, bottom_clothes, torso_skin, left_arm, right_arm, left_leg, right_leg, left_foot, right_foot, detail_method, detail_erode, detail_dilate, black_point, white_point, process_detail, device, max_megapixels
         */
        inputs?: {
            image: unknown;
            face: unknown;
            hair: unknown;
            glasses: unknown;
            top_clothes: unknown;
            bottom_clothes: unknown;
            torso_skin: unknown;
            left_arm: unknown;
            right_arm: unknown;
            left_leg: unknown;
            right_leg: unknown;
            left_foot: unknown;
            right_foot: unknown;
            detail_method: string;
            detail_erode: number;
            detail_dilate: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            device: string;
            max_megapixels: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageAutoCrop {
        /**
         * INPUT_TYPES: image, background_color, aspect_ratio, proportional_width, proportional_height, scale_to_longest_side, longest_side, detect, border_reserve, ultra_detail_range, matting_method, sam_model, grounding_dino_model, sam_threshold, sam_prompt
         */
        inputs?: {
            image: unknown;
            background_color: string;
            aspect_ratio: string;
            proportional_width: number;
            proportional_height: number;
            scale_to_longest_side: unknown;
            longest_side: number;
            detect: string;
            border_reserve: number;
            ultra_detail_range: number;
            matting_method: string;
            sam_model: string;
            grounding_dino_model: string;
            sam_threshold: number;
            sam_prompt: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE, MASK
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageAutoCrop_V2 {
        /**
         * INPUT_TYPES: image, fill_background, background_color, aspect_ratio, proportional_width, proportional_height, scale_to_side, scale_to_length, detect, border_reserve, ultra_detail_range, matting_method, sam_model, grounding_dino_model, sam_threshold, sam_prompt
         */
        inputs?: {
            image: unknown;
            fill_background: unknown;
            background_color: string;
            aspect_ratio: string;
            proportional_width: number;
            proportional_height: number;
            scale_to_side: string;
            scale_to_length: number;
            detect: string;
            border_reserve: number;
            ultra_detail_range: number;
            matting_method: string;
            sam_model: string;
            grounding_dino_model: string;
            sam_threshold: number;
            sam_prompt: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE, MASK
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageAutoCrop_V3 {
        /**
         * INPUT_TYPES: image, aspect_ratio, proportional_width, proportional_height, method, scale_to_side, scale_to_length, round_to_multiple
         */
        inputs?: {
            image: unknown;
            aspect_ratio: string;
            proportional_width: number;
            proportional_height: number;
            method: string;
            scale_to_side: string;
            scale_to_length: number;
            round_to_multiple: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageBlend {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageBlendAdvance {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity, x_percent, y_percent, mirror, scale, aspect_ratio, rotate, transform_method, anti_aliasing
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            x_percent: number;
            y_percent: number;
            mirror: string;
            scale: number;
            aspect_ratio: number;
            rotate: number;
            transform_method: string;
            anti_aliasing: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageBlendAdvance_V2 {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity, x_percent, y_percent, mirror, scale, aspect_ratio, rotate, transform_method, anti_aliasing
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            x_percent: number;
            y_percent: number;
            mirror: string;
            scale: number;
            aspect_ratio: number;
            rotate: number;
            transform_method: string;
            anti_aliasing: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageBlend_V2 {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageChannelMerge {
        /**
         * INPUT_TYPES: channel_1, channel_2, channel_3, mode
         */
        inputs?: {
            channel_1: unknown;
            channel_2: unknown;
            channel_3: unknown;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageChannelSplit {
        /**
         * INPUT_TYPES: image, mode
         */
        inputs?: {
            image: unknown;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE, IMAGE, IMAGE
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageCombineAlpha {
        /**
         * INPUT_TYPES: RGB_image, mask
         */
        inputs?: {
            RGB_image: unknown;
            mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageHub {
        /**
         * INPUT_TYPES: output, random_output
         */
        inputs?: {
            output: number;
            random_output: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageMaskScaleAs {
        /**
         * INPUT_TYPES: scale_as, fit, method
         */
        inputs?: {
            scale_as: string;
            fit: string;
            method: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, BOX, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageOpacity {
        /**
         * INPUT_TYPES: image, opacity, invert_mask
         */
        inputs?: {
            image: unknown;
            opacity: number;
            invert_mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageReel {
        /**
         * INPUT_TYPES: image1, image1_text, image2_text, image3_text, image4_text, reel_height, border
         */
        inputs?: {
            image1: unknown;
            image1_text: string;
            image2_text: string;
            image3_text: string;
            image4_text: string;
            reel_height: number;
            border: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: Reel
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageReelComposit {
        /**
         * INPUT_TYPES: reel_1, font_file, font_size, border, color_theme
         */
        inputs?: {
            reel_1: unknown;
            font_file: string;
            font_size: number;
            border: number;
            color_theme: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageRemoveAlpha {
        /**
         * INPUT_TYPES: RGBA_image, fill_background, background_color
         */
        inputs?: {
            RGBA_image: unknown;
            fill_background: unknown;
            background_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageRewardFilter {
        /**
         * INPUT_TYPES: images, prompt, output_num
         */
        inputs?: {
            images: unknown;
            prompt: string;
            output_num: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageScaleByAspectRatio {
        /**
         * INPUT_TYPES: aspect_ratio, proportional_width, proportional_height, fit, method, round_to_multiple, scale_to_longest_side, longest_side
         */
        inputs?: {
            aspect_ratio: string;
            proportional_width: number;
            proportional_height: number;
            fit: string;
            method: string;
            round_to_multiple: string;
            scale_to_longest_side: unknown;
            longest_side: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, BOX, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageScaleByAspectRatio_V2 {
        /**
         * INPUT_TYPES: aspect_ratio, proportional_width, proportional_height, fit, method, round_to_multiple, scale_to_side, scale_to_length, background_color
         */
        inputs?: {
            aspect_ratio: string;
            proportional_width: number;
            proportional_height: number;
            fit: string;
            method: string;
            round_to_multiple: string;
            scale_to_side: string;
            scale_to_length: number;
            background_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, BOX, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageScaleRestore {
        /**
         * INPUT_TYPES: image, scale, method, scale_by_longest_side, longest_side
         */
        inputs?: {
            image: unknown;
            scale: number;
            method: string;
            scale_by_longest_side: unknown;
            longest_side: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, BOX, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageScaleRestore_V2 {
        /**
         * INPUT_TYPES: image, scale, method, scale_by, scale_by_length
         */
        inputs?: {
            image: unknown;
            scale: number;
            method: string;
            scale_by: string;
            scale_by_length: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, BOX, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageShift {
        /**
         * INPUT_TYPES: image, shift_x, shift_y, cyclic, background_color, border_mask_width, border_mask_blur
         */
        inputs?: {
            image: unknown;
            shift_x: number;
            shift_y: number;
            cyclic: unknown;
            background_color: string;
            border_mask_width: number;
            border_mask_blur: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, MASK
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ImageTaggerSave {
        /**
         * INPUT_TYPES: image, tag_text, custom_path, filename_prefix, timestamp, format, quality, preview
         */
        inputs?: {
            image: unknown;
            tag_text: string;
            custom_path: string;
            filename_prefix: string;
            timestamp: string;
            format: string;
            quality: number;
            preview: unknown;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface LayerMask__ImageToMask {
        /**
         * INPUT_TYPES: image, channel, black_point, white_point, gray_point, invert_output_mask
         */
        inputs?: {
            image: unknown;
            channel: string;
            black_point: number;
            white_point: number;
            gray_point: number;
            invert_output_mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerStyle__InnerGlow {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity, brightness, glow_range, blur, light_color, glow_color
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            brightness: number;
            glow_range: number;
            blur: number;
            light_color: string;
            glow_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerStyle__InnerGlow_V2 {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity, brightness, glow_range, blur, light_color, glow_color
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            brightness: number;
            glow_range: number;
            blur: number;
            light_color: string;
            glow_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerStyle__InnerShadow {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity, distance_x, distance_y, grow, blur, shadow_color
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            distance_x: number;
            distance_y: number;
            grow: number;
            blur: number;
            shadow_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerStyle__InnerShadow_V2 {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity, distance_x, distance_y, grow, blur, shadow_color
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            distance_x: number;
            distance_y: number;
            grow: number;
            blur: number;
            shadow_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__LoadJoyCaption2Model {
        /**
         * INPUT_TYPES: llm_model, device, dtype, vlm_lora
         */
        inputs?: {
            llm_model: string;
            device: string;
            dtype: string;
            vlm_lora: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: JoyCaption2_Model
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__JoyCaption2Split {
        /**
         * INPUT_TYPES: image, joy2_model, caption_type, caption_length, user_prompt, max_new_tokens, top_p, temperature
         */
        inputs?: {
            image: unknown;
            joy2_model: unknown;
            caption_type: string;
            caption_length: string;
            user_prompt: string;
            max_new_tokens: number;
            top_p: number;
            temperature: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__JoyCaption2 {
        /**
         * INPUT_TYPES: image, llm_model, device, dtype, vlm_lora, caption_type, caption_length, user_prompt, max_new_tokens, top_p, temperature, cache_model, use_global_model
         */
        inputs?: {
            image: unknown;
            llm_model: string;
            device: string;
            dtype: string;
            vlm_lora: string;
            caption_type: string;
            caption_length: string;
            user_prompt: string;
            max_new_tokens: number;
            top_p: number;
            temperature: number;
            cache_model: unknown;
            use_global_model: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__JoyCaption2ExtraOptions {
        /**
         * INPUT_TYPES: refer_character_name, exclude_people_info, include_lighting, include_camera_angle, include_watermark, include_JPEG_artifacts, include_exif, exclude_sexual, exclude_image_resolution, include_aesthetic_quality, include_composition_style, exclude_text, specify_depth_field, specify_lighting_sources, do_not_use_ambiguous_language, include_nsfw, only_describe_most_important_elements, character_name
         */
        inputs?: {
            refer_character_name: unknown;
            exclude_people_info: unknown;
            include_lighting: unknown;
            include_camera_angle: unknown;
            include_watermark: unknown;
            include_JPEG_artifacts: unknown;
            include_exif: unknown;
            exclude_sexual: unknown;
            exclude_image_resolution: unknown;
            include_aesthetic_quality: unknown;
            include_composition_style: unknown;
            exclude_text: unknown;
            specify_depth_field: unknown;
            specify_lighting_sources: unknown;
            do_not_use_ambiguous_language: unknown;
            include_nsfw: unknown;
            only_describe_most_important_elements: unknown;
            character_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: JoyCaption2ExtraOption
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__LaMa {
        /**
         * INPUT_TYPES: image, mask, lama_model, device, invert_mask, mask_grow, mask_blur
         */
        inputs?: {
            image: unknown;
            mask: unknown;
            lama_model: string;
            device: string;
            invert_mask: unknown;
            mask_grow: number;
            mask_blur: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__LayerImageTransform {
        /**
         * INPUT_TYPES: image, x, y, mirror, scale, aspect_ratio, rotate, transform_method, anti_aliasing
         */
        inputs?: {
            image: unknown;
            x: number;
            y: number;
            mirror: string;
            scale: number;
            aspect_ratio: number;
            rotate: number;
            transform_method: string;
            anti_aliasing: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__LayerMaskTransform {
        /**
         * INPUT_TYPES: mask, x, y, mirror, scale, aspect_ratio, rotate, transform_method, anti_aliasing
         */
        inputs?: {
            mask: unknown;
            x: number;
            y: number;
            mirror: string;
            scale: number;
            aspect_ratio: number;
            rotate: number;
            transform_method: string;
            anti_aliasing: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerFilter__LightLeak {
        /**
         * INPUT_TYPES: image, light, corner, hue, saturation, opacity
         */
        inputs?: {
            image: unknown;
            light: string;
            corner: string;
            hue: number;
            saturation: number;
            opacity: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__LlamaVision {
        /**
         * INPUT_TYPES: image, model, system_prompt, user_prompt, max_new_tokens, do_sample, temperature, top_p, top_k, stop_strings, seed, include_prompt_in_output, cache_model
         */
        inputs?: {
            image: unknown;
            model: string;
            system_prompt: string;
            user_prompt: string;
            max_new_tokens: number;
            do_sample: unknown;
            temperature: number;
            top_p: number;
            top_k: number;
            stop_strings: string;
            seed: number;
            include_prompt_in_output: unknown;
            cache_model: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__LoadPSD {
        /**
         * INPUT_TYPES: image, file_path, include_hidden_layer, find_layer_by, layer_index, layer_name
         */
        inputs?: {
            image: string;
            file_path: string;
            include_hidden_layer: unknown;
            find_layer_by: string;
            layer_index: number;
            layer_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE, IMAGE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__MaskBoxDetect {
        /**
         * INPUT_TYPES: mask, detect, x_adjust, y_adjust, scale_adjust
         */
        inputs?: {
            mask: unknown;
            detect: string;
            x_adjust: number;
            y_adjust: number;
            scale_adjust: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, FLOAT, FLOAT, INT, INT, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__MaskByColor {
        /**
         * INPUT_TYPES: image, color, color_in_HEX, threshold, fix_gap, fix_threshold, invert_mask
         */
        inputs?: {
            image: unknown;
            color: unknown;
            color_in_HEX: string;
            threshold: number;
            fix_gap: number;
            fix_threshold: number;
            invert_mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__MaskByDifferent {
        /**
         * INPUT_TYPES: image_1, image_2, gain, fix_gap, fix_threshold, main_subject_detect
         */
        inputs?: {
            image_1: unknown;
            image_2: unknown;
            gain: number;
            fix_gap: number;
            fix_threshold: number;
            main_subject_detect: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__MaskEdgeShrink {
        /**
         * INPUT_TYPES: mask, invert_mask, shrink_level, soft, edge_shrink, edge_reserve
         */
        inputs?: {
            mask: unknown;
            invert_mask: unknown;
            shrink_level: number;
            soft: number;
            edge_shrink: number;
            edge_reserve: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__MaskEdgeUltraDetail {
        /**
         * INPUT_TYPES: image, mask, method, mask_grow, fix_gap, fix_threshold, detail_range, black_point, white_point
         */
        inputs?: {
            image: unknown;
            mask: unknown;
            method: string;
            mask_grow: number;
            fix_gap: number;
            fix_threshold: number;
            detail_range: number;
            black_point: number;
            white_point: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__MaskEdgeUltraDetail_V2 {
        /**
         * INPUT_TYPES: image, mask, method, mask_grow, fix_gap, fix_threshold, edge_erode, edte_dilate, black_point, white_point, device, max_megapixels
         */
        inputs?: {
            image: unknown;
            mask: unknown;
            method: string;
            mask_grow: number;
            fix_gap: number;
            fix_threshold: number;
            edge_erode: number;
            edte_dilate: number;
            black_point: number;
            white_point: number;
            device: string;
            max_megapixels: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__MaskGradient {
        /**
         * INPUT_TYPES: mask, invert_mask, gradient_side, gradient_scale, gradient_offset, opacity
         */
        inputs?: {
            mask: unknown;
            invert_mask: unknown;
            gradient_side: string;
            gradient_scale: number;
            gradient_offset: number;
            opacity: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__MaskGrain {
        /**
         * INPUT_TYPES: mask, grain, invert_mask
         */
        inputs?: {
            mask: unknown;
            grain: number;
            invert_mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__MaskGrow {
        /**
         * INPUT_TYPES: mask, invert_mask, grow, blur
         */
        inputs?: {
            mask: unknown;
            invert_mask: unknown;
            grow: number;
            blur: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__MaskInvert {
        /**
         * INPUT_TYPES: mask
         */
        inputs?: {
            mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__MaskMotionBlur {
        /**
         * INPUT_TYPES: mask, invert_mask, blur, angle
         */
        inputs?: {
            mask: unknown;
            invert_mask: unknown;
            blur: number;
            angle: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__MaskPreview {
        /**
         * INPUT_TYPES: mask
         */
        inputs?: {
            mask: unknown;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface LayerMask__MaskStroke {
        /**
         * INPUT_TYPES: mask, invert_mask, stroke_grow, stroke_width, blur
         */
        inputs?: {
            mask: unknown;
            invert_mask: unknown;
            stroke_grow: number;
            stroke_width: number;
            blur: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__MediapipeFacialSegment {
        /**
         * INPUT_TYPES: image, left_eye, left_eyebrow, right_eye, right_eyebrow, lips, tooth
         */
        inputs?: {
            image: unknown;
            left_eye: unknown;
            left_eyebrow: unknown;
            right_eye: unknown;
            right_eyebrow: unknown;
            lips: unknown;
            tooth: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerFilter__MotionBlur {
        /**
         * INPUT_TYPES: image, angle, blur
         */
        inputs?: {
            image: unknown;
            angle: number;
            blur: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__BBoxJoin {
        /**
         * INPUT_TYPES: bboxes_1
         */
        inputs?: {
            bboxes_1: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BBOXES
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__DrawBBoxMask {
        /**
         * INPUT_TYPES: image, bboxes, grow_top, grow_bottom, grow_left, grow_right
         */
        inputs?: {
            image: unknown;
            bboxes: unknown;
            grow_top: number;
            grow_bottom: number;
            grow_left: number;
            grow_right: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__ObjectDetectorFL2 {
        /**
         * INPUT_TYPES: image, prompt, florence2_model, sort_method, bbox_select, select_index
         */
        inputs?: {
            image: unknown;
            prompt: string;
            florence2_model: unknown;
            sort_method: string;
            bbox_select: string;
            select_index: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BBOXES, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__ObjectDetectorMask {
        /**
         * INPUT_TYPES: object_mask, sort_method, bbox_select, select_index
         */
        inputs?: {
            object_mask: unknown;
            sort_method: string;
            bbox_select: string;
            select_index: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BBOXES, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__ObjectDetectorYOLO8 {
        /**
         * INPUT_TYPES: image, yolo_model, sort_method, bbox_select, select_index
         */
        inputs?: {
            image: unknown;
            yolo_model: string;
            sort_method: string;
            bbox_select: string;
            select_index: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BBOXES, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__ObjectDetectorYOLOWorld {
        /**
         * INPUT_TYPES: image, yolo_world_model, confidence_threshold, nms_iou_threshold, prompt, sort_method, bbox_select, select_index
         */
        inputs?: {
            image: unknown;
            yolo_world_model: string;
            confidence_threshold: number;
            nms_iou_threshold: number;
            prompt: string;
            sort_method: string;
            bbox_select: string;
            select_index: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BBOXES, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerStyle__OuterGlow {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity, brightness, glow_range, blur, light_color, glow_color
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            brightness: number;
            glow_range: number;
            blur: number;
            light_color: string;
            glow_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerStyle__OuterGlow_V2 {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity, brightness, glow_range, blur, light_color, glow_color
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            brightness: number;
            glow_range: number;
            blur: number;
            light_color: string;
            glow_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__PersonMaskUltra {
        /**
         * INPUT_TYPES: images, face, hair, body, clothes, accessories, background, confidence, detail_range, black_point, white_point, process_detail
         */
        inputs?: {
            images: unknown;
            face: unknown;
            hair: unknown;
            body: unknown;
            clothes: unknown;
            accessories: unknown;
            background: unknown;
            confidence: number;
            detail_range: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__PersonMaskUltra_V2 {
        /**
         * INPUT_TYPES: images, face, hair, body, clothes, accessories, background, confidence, detail_method, detail_erode, detail_dilate, black_point, white_point, process_detail, device, max_megapixels
         */
        inputs?: {
            images: unknown;
            face: unknown;
            hair: unknown;
            body: unknown;
            clothes: unknown;
            accessories: unknown;
            background: unknown;
            confidence: number;
            detail_method: string;
            detail_erode: number;
            detail_dilate: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            device: string;
            max_megapixels: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__PhiPrompt {
        /**
         * INPUT_TYPES: model, device, dtype, cache_model, system_prompt, user_prompt, do_sample, temperature, max_new_tokens
         */
        inputs?: {
            model: string;
            device: string;
            dtype: string;
            cache_model: unknown;
            system_prompt: string;
            user_prompt: string;
            do_sample: unknown;
            temperature: number;
            max_new_tokens: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__PixelSpread {
        /**
         * INPUT_TYPES: image, invert_mask, mask_grow
         */
        inputs?: {
            image: unknown;
            invert_mask: unknown;
            mask_grow: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__PrintInfo {
        /**
         * INPUT_TYPES: anything
         */
        inputs?: {
            anything: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__PromptEmbellish {
        /**
         * INPUT_TYPES: api, token_limit, describe
         */
        inputs?: {
            api: string;
            token_limit: number;
            describe: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__PromptTagger {
        /**
         * INPUT_TYPES: image, api, token_limit, exclude_word, replace_with_word
         */
        inputs?: {
            image: unknown;
            api: string;
            token_limit: number;
            exclude_word: string;
            replace_with_word: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__PurgeVRAM {
        /**
         * INPUT_TYPES: anything, purge_cache, purge_models
         */
        inputs?: {
            anything: string;
            purge_cache: unknown;
            purge_models: unknown;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface LayerUtility__CreateQRCode {
        /**
         * INPUT_TYPES: size, border, text
         */
        inputs?: {
            size: number;
            border: number;
            text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__DecodeQRCode {
        /**
         * INPUT_TYPES: image, pre_blur
         */
        inputs?: {
            image: unknown;
            pre_blur: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__QWenImage2Prompt {
        /**
         * INPUT_TYPES: image, question
         */
        inputs?: {
            image: unknown;
            question: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__RandomGenerator {
        /**
         * INPUT_TYPES: min_value, max_value, float_decimal_places, fix_seed
         */
        inputs?: {
            min_value: number;
            max_value: number;
            float_decimal_places: number;
            fix_seed: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, FLOAT, BOOLEAN
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__RandomGeneratorV2 {
        /**
         * INPUT_TYPES: min_value, max_value, least, float_decimal_places, seed
         */
        inputs?: {
            min_value: number;
            max_value: number;
            least: number;
            float_decimal_places: number;
            seed: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, FLOAT, BOOLEAN
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__RestoreCropBox {
        /**
         * INPUT_TYPES: background_image, croped_image, invert_mask, crop_box
         */
        inputs?: {
            background_image: unknown;
            croped_image: unknown;
            invert_mask: unknown;
            crop_box: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__RemBgUltra {
        /**
         * INPUT_TYPES: image, detail_range, black_point, white_point, process_detail
         */
        inputs?: {
            image: unknown;
            detail_range: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__RmBgUltra_V2 {
        /**
         * INPUT_TYPES: image, detail_method, detail_erode, detail_dilate, black_point, white_point, process_detail, device, max_megapixels
         */
        inputs?: {
            image: unknown;
            detail_method: string;
            detail_erode: number;
            detail_dilate: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            device: string;
            max_megapixels: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__SAM2Ultra {
        /**
         * INPUT_TYPES: image, bboxes, sam2_model, precision, bbox_select, select_index, cache_model, detail_method, detail_erode, detail_dilate, black_point, white_point, process_detail, device, max_megapixels
         */
        inputs?: {
            image: unknown;
            bboxes: unknown;
            sam2_model: string;
            precision: string;
            bbox_select: string;
            select_index: string;
            cache_model: unknown;
            detail_method: string;
            detail_erode: number;
            detail_dilate: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            device: string;
            max_megapixels: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__SAM2VideoUltra {
        /**
         * INPUT_TYPES: image, sam2_model, precision, cache_model, individual_objects, mask_preview_color, detail_method, detail_erode, detail_dilate, black_point, white_point, process_detail, device, max_megapixels
         */
        inputs?: {
            image: unknown;
            sam2_model: string;
            precision: string;
            cache_model: unknown;
            individual_objects: unknown;
            mask_preview_color: string;
            detail_method: string;
            detail_erode: number;
            detail_dilate: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            device: string;
            max_megapixels: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__SaveImagePlus {
        /**
         * INPUT_TYPES: images, custom_path, filename_prefix, timestamp, format, quality, meta_data, blind_watermark, save_workflow_as_json, preview
         */
        inputs?: {
            images: unknown;
            custom_path: string;
            filename_prefix: string;
            timestamp: string;
            format: string;
            quality: number;
            meta_data: unknown;
            blind_watermark: string;
            save_workflow_as_json: unknown;
            preview: unknown;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface LayerUtility__SD3NegativeConditioning {
        /**
         * INPUT_TYPES: conditioning, zero_out_start
         */
        inputs?: {
            conditioning: unknown;
            zero_out_start: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__SegformerB2ClothesUltra {
        /**
         * INPUT_TYPES: image, face, hair, hat, sunglass, left_arm, right_arm, left_leg, right_leg, upper_clothes, skirt, pants, dress, belt, shoe, bag, scarf, detail_method, detail_erode, detail_dilate, black_point, white_point, process_detail, device, max_megapixels
         */
        inputs?: {
            image: unknown;
            face: unknown;
            hair: unknown;
            hat: unknown;
            sunglass: unknown;
            left_arm: unknown;
            right_arm: unknown;
            left_leg: unknown;
            right_leg: unknown;
            upper_clothes: unknown;
            skirt: unknown;
            pants: unknown;
            dress: unknown;
            belt: unknown;
            shoe: unknown;
            bag: unknown;
            scarf: unknown;
            detail_method: string;
            detail_erode: number;
            detail_dilate: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            device: string;
            max_megapixels: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__SegformerUltraV2 {
        /**
         * INPUT_TYPES: image, segformer_pipeline, detail_method, detail_erode, detail_dilate, black_point, white_point, process_detail, device, max_megapixels
         */
        inputs?: {
            image: unknown;
            segformer_pipeline: unknown;
            detail_method: string;
            detail_erode: number;
            detail_dilate: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            device: string;
            max_megapixels: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__SegformerClothesPipelineLoader {
        /**
         * INPUT_TYPES: model, face, hair, hat, sunglass, left_arm, right_arm, left_leg, right_leg, left_shoe, right_shoe, upper_clothes, skirt, pants, dress, belt, bag, scarf
         */
        inputs?: {
            model: string;
            face: unknown;
            hair: unknown;
            hat: unknown;
            sunglass: unknown;
            left_arm: unknown;
            right_arm: unknown;
            left_leg: unknown;
            right_leg: unknown;
            left_shoe: unknown;
            right_shoe: unknown;
            upper_clothes: unknown;
            skirt: unknown;
            pants: unknown;
            dress: unknown;
            belt: unknown;
            bag: unknown;
            scarf: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SegPipeline
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__SegformerFashionPipelineLoader {
        /**
         * INPUT_TYPES: model, shirt, top, sweater, cardigan, jacket, vest, pants, shorts, skirt, coat, dress, jumpsuit, cape, glasses, hat, hairaccessory, tie, glove, watch, belt, legwarmer, tights, sock, shoe, bagwallet, scarf, umbrella, hood, collar, lapel, epaulette, sleeve, pocket, neckline, buckle, zipper, applique, bead, bow, flower, fringe, ribbon, rivet, ruffle, sequin, tassel
         */
        inputs?: {
            model: string;
            shirt: unknown;
            top: unknown;
            sweater: unknown;
            cardigan: unknown;
            jacket: unknown;
            vest: unknown;
            pants: unknown;
            shorts: unknown;
            skirt: unknown;
            coat: unknown;
            dress: unknown;
            jumpsuit: unknown;
            cape: unknown;
            glasses: unknown;
            hat: unknown;
            hairaccessory: unknown;
            tie: unknown;
            glove: unknown;
            watch: unknown;
            belt: unknown;
            legwarmer: unknown;
            tights: unknown;
            sock: unknown;
            shoe: unknown;
            bagwallet: unknown;
            scarf: unknown;
            umbrella: unknown;
            hood: unknown;
            collar: unknown;
            lapel: unknown;
            epaulette: unknown;
            sleeve: unknown;
            pocket: unknown;
            neckline: unknown;
            buckle: unknown;
            zipper: unknown;
            applique: unknown;
            bead: unknown;
            bow: unknown;
            flower: unknown;
            fringe: unknown;
            ribbon: unknown;
            rivet: unknown;
            ruffle: unknown;
            sequin: unknown;
            tassel: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SegPipeline
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__SegmentAnythingUltra {
        /**
         * INPUT_TYPES: image, sam_model, grounding_dino_model, threshold, detail_range, black_point, white_point, process_detail, prompt, cache_model
         */
        inputs?: {
            image: unknown;
            sam_model: string;
            grounding_dino_model: string;
            threshold: number;
            detail_range: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            prompt: string;
            cache_model: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__SegmentAnythingUltra_V2 {
        /**
         * INPUT_TYPES: image, sam_model, grounding_dino_model, threshold, detail_method, detail_erode, detail_dilate, black_point, white_point, process_detail, prompt, device, max_megapixels, cache_model
         */
        inputs?: {
            image: unknown;
            sam_model: string;
            grounding_dino_model: string;
            threshold: number;
            detail_method: string;
            detail_erode: number;
            detail_dilate: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            prompt: string;
            device: string;
            max_megapixels: number;
            cache_model: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__Shadow___Highlight_Mask {
        /**
         * INPUT_TYPES: image, shadow_level_offset, shadow_range, highlight_level_offset, highlight_range
         */
        inputs?: {
            image: unknown;
            shadow_level_offset: number;
            shadow_range: number;
            highlight_level_offset: number;
            highlight_range: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__ShadowHighlightMaskV2 {
        /**
         * INPUT_TYPES: image, shadow_level_offset, shadow_range, highlight_level_offset, highlight_range
         */
        inputs?: {
            image: unknown;
            shadow_level_offset: number;
            shadow_range: number;
            highlight_level_offset: number;
            highlight_range: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerFilter__Sharp___Soft {
        /**
         * INPUT_TYPES: images, enhance
         */
        inputs?: {
            images: unknown;
            enhance: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__SimpleTextImage {
        /**
         * INPUT_TYPES: text, font_file, align, char_per_line, leading, font_size, text_color, stroke_width, stroke_color, x_offset, y_offset, width, height
         */
        inputs?: {
            text: string;
            font_file: string;
            align: string;
            char_per_line: number;
            leading: number;
            font_size: number;
            text_color: string;
            stroke_width: number;
            stroke_color: string;
            x_offset: number;
            y_offset: number;
            width: number;
            height: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerFilter__SkinBeauty {
        /**
         * INPUT_TYPES: image, smooth, threshold, opacity
         */
        inputs?: {
            image: unknown;
            smooth: number;
            threshold: number;
            opacity: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerFilter__SoftLight {
        /**
         * INPUT_TYPES: image, soft, threshold, opacity
         */
        inputs?: {
            image: unknown;
            soft: number;
            threshold: number;
            opacity: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerStyle__Stroke {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity, stroke_grow, stroke_width, blur, stroke_color
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            stroke_grow: number;
            stroke_width: number;
            blur: number;
            stroke_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerStyle__Stroke_V2 {
        /**
         * INPUT_TYPES: background_image, layer_image, invert_mask, blend_mode, opacity, stroke_grow, stroke_width, blur, stroke_color
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            invert_mask: unknown;
            blend_mode: string;
            opacity: number;
            stroke_grow: number;
            stroke_width: number;
            blur: number;
            stroke_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__TextImage {
        /**
         * INPUT_TYPES: text, font_file, spacing, leading, horizontal_border, vertical_border, scale, variation_range, variation_seed, layout, width, height, text_color, background_color
         */
        inputs?: {
            text: string;
            font_file: string;
            spacing: number;
            leading: number;
            horizontal_border: number;
            vertical_border: number;
            scale: number;
            variation_range: number;
            variation_seed: number;
            layout: string;
            width: number;
            height: number;
            text_color: string;
            background_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__TextImage_V2 {
        /**
         * INPUT_TYPES: text, font_file, spacing, leading, horizontal_border, vertical_border, scale, variation_range, variation_seed, layout, width, height, text_color, background_color
         */
        inputs?: {
            text: string;
            font_file: string;
            spacing: number;
            leading: number;
            horizontal_border: number;
            vertical_border: number;
            scale: number;
            variation_range: number;
            variation_seed: number;
            layout: string;
            width: number;
            height: number;
            text_color: string;
            background_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__TextJoin {
        /**
         * INPUT_TYPES: text_1
         */
        inputs?: {
            text_1: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__TextJoinV2 {
        /**
         * INPUT_TYPES: text_1, delimiter
         */
        inputs?: {
            text_1: string;
            delimiter: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__TransparentBackgroundUltra {
        /**
         * INPUT_TYPES: image, model, detail_method, detail_erode, detail_dilate, black_point, white_point, process_detail, device, max_megapixels
         */
        inputs?: {
            image: unknown;
            model: string;
            detail_method: string;
            detail_erode: number;
            detail_dilate: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            device: string;
            max_megapixels: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__UserPromptGeneratorTxt2ImgPrompt {
        /**
         * INPUT_TYPES: template, describe, limit_words
         */
        inputs?: {
            template: string;
            describe: string;
            limit_words: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__UserPromptGeneratorTxt2ImgPromptWithReference {
        /**
         * INPUT_TYPES: template, reference_text, describe, limit_words
         */
        inputs?: {
            template: string;
            reference_text: string;
            describe: string;
            limit_words: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__UserPromptGeneratorReplaceWord {
        /**
         * INPUT_TYPES: orig_prompt, template, exclude_word, replace_with_word
         */
        inputs?: {
            orig_prompt: string;
            template: string;
            exclude_word: string;
            replace_with_word: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__VQAPrompt {
        /**
         * INPUT_TYPES: image, vqa_model, question
         */
        inputs?: {
            image: unknown;
            vqa_model: unknown;
            question: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__LoadVQAModel {
        /**
         * INPUT_TYPES: model, precision, device
         */
        inputs?: {
            model: string;
            precision: string;
            device: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: VQA_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__AddBlindWaterMark {
        /**
         * INPUT_TYPES: image, watermark_image
         */
        inputs?: {
            image: unknown;
            watermark_image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ShowBlindWaterMark {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerFilter__WaterColor {
        /**
         * INPUT_TYPES: image, line_density, opacity
         */
        inputs?: {
            image: unknown;
            line_density: number;
            opacity: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__XY_to_Percent {
        /**
         * INPUT_TYPES: background_image, layer_image, x, y
         */
        inputs?: {
            background_image: unknown;
            layer_image: unknown;
            x: number;
            y: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT, FLOAT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__YoloV8Detect {
        /**
         * INPUT_TYPES: image, yolo_model, mask_merge
         */
        inputs?: {
            image: unknown;
            yolo_model: string;
            mask_merge: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK, IMAGE, MASK
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__Collage {
        /**
         * INPUT_TYPES: images, canvas_width, canvas_height, border_width, rounded_rect_radius, uniformity, background_color, seed
         */
        inputs?: {
            images: unknown;
            canvas_width: number;
            canvas_height: number;
            border_width: number;
            rounded_rect_radius: number;
            uniformity: number;
            background_color: string;
            seed: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__DeepSeekAPI {
        /**
         * INPUT_TYPES: model, max_tokens, temperature, top_p, presence_penalty, frequency_penalty, history_length, system_prompt, user_prompt
         */
        inputs?: {
            model: string;
            max_tokens: number;
            temperature: number;
            top_p: number;
            presence_penalty: number;
            frequency_penalty: number;
            history_length: number;
            system_prompt: string;
            user_prompt: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, DEEPSEEK_HISTORY
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__DeepSeekAPIV2 {
        /**
         * INPUT_TYPES: model, time_out, max_tokens, temperature, top_p, presence_penalty, frequency_penalty, history_length, system_prompt, user_prompt
         */
        inputs?: {
            model: string;
            time_out: number;
            max_tokens: number;
            temperature: number;
            top_p: number;
            presence_penalty: number;
            frequency_penalty: number;
            history_length: number;
            system_prompt: string;
            user_prompt: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, DEEPSEEK_HISTORY
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__Gemini {
        /**
         * INPUT_TYPES: model, max_output_tokens, temperature, words_limit, response_language, system_prompt, user_prompt
         */
        inputs?: {
            model: string;
            max_output_tokens: number;
            temperature: number;
            words_limit: number;
            response_language: string;
            system_prompt: string;
            user_prompt: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__GeminiV2 {
        /**
         * INPUT_TYPES: model, max_output_tokens, temperature, words_limit, response_language, seed, system_prompt, user_prompt
         */
        inputs?: {
            model: string;
            max_output_tokens: number;
            temperature: number;
            words_limit: number;
            response_language: string;
            seed: number;
            system_prompt: string;
            user_prompt: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__ObjectDetectorGemini {
        /**
         * INPUT_TYPES: image, model, prompt
         */
        inputs?: {
            image: unknown;
            model: string;
            prompt: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BBOXES, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__ObjectDetectorGeminiV2 {
        /**
         * INPUT_TYPES: image, model, prompt
         */
        inputs?: {
            image: unknown;
            model: string;
            prompt: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BBOXES, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__GeminiImageEdit {
        /**
         * INPUT_TYPES: image, model, temperature, seed, user_prompt
         */
        inputs?: {
            image: unknown;
            model: string;
            temperature: number;
            seed: number;
            user_prompt: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__JoyCaptionBeta1 {
        /**
         * INPUT_TYPES: image, joycaption_beta1_model, caption_type, caption_length, max_new_tokens, top_p, top_k, temperature, user_prompt
         */
        inputs?: {
            image: unknown;
            joycaption_beta1_model: unknown;
            caption_type: string;
            caption_length: string;
            max_new_tokens: number;
            top_p: number;
            top_k: number;
            temperature: number;
            user_prompt: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__LoadJoyCaptionBeta1Model {
        /**
         * INPUT_TYPES: model, quantization_mode, device
         */
        inputs?: {
            model: string;
            quantization_mode: string;
            device: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: JOYCAPTIONBETA1_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__JoyCaptionBeta1ExtraOptions {
        /**
         * INPUT_TYPES: refer_character_name, exclude_people_info, include_lighting, include_camera_angle, include_watermark, include_JPEG_artifacts, include_exif, exclude_sexual, exclude_image_resolution, include_aesthetic_quality, include_composition_style, exclude_text, specify_depth_field, specify_lighting_sources, do_not_use_ambiguous_language, include_nsfw, only_describe_most_important_elements, do_not_include_artist_name_or_title, identify_image_orientation, use_vulgar_slang_and_profanity, do_not_use_polite_euphemisms, include_character_age, include_camera_shot_type, exclude_mood_feeling, include_camera_vantage_height, mention_watermark, avoid_meta_descriptive_phrases, character_name
         */
        inputs?: {
            refer_character_name: unknown;
            exclude_people_info: unknown;
            include_lighting: unknown;
            include_camera_angle: unknown;
            include_watermark: unknown;
            include_JPEG_artifacts: unknown;
            include_exif: unknown;
            exclude_sexual: unknown;
            exclude_image_resolution: unknown;
            include_aesthetic_quality: unknown;
            include_composition_style: unknown;
            exclude_text: unknown;
            specify_depth_field: unknown;
            specify_lighting_sources: unknown;
            do_not_use_ambiguous_language: unknown;
            include_nsfw: unknown;
            only_describe_most_important_elements: unknown;
            do_not_include_artist_name_or_title: unknown;
            identify_image_orientation: unknown;
            use_vulgar_slang_and_profanity: unknown;
            do_not_use_polite_euphemisms: unknown;
            include_character_age: unknown;
            include_camera_shot_type: unknown;
            exclude_mood_feeling: unknown;
            include_camera_vantage_height: unknown;
            mention_watermark: unknown;
            avoid_meta_descriptive_phrases: unknown;
            character_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: JoyCaption2ExtraOption
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__DrawBBoxMaskV2 {
        /**
         * INPUT_TYPES: image, bboxes, grow_top, grow_bottom, grow_left, grow_right, rounded_rect_radius, anti_aliasing
         */
        inputs?: {
            image: unknown;
            bboxes: unknown;
            grow_top: number;
            grow_bottom: number;
            grow_left: number;
            grow_right: number;
            rounded_rect_radius: number;
            anti_aliasing: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerMask__SAM2UltraV2 {
        /**
         * INPUT_TYPES: sam2_model, image, bboxes, bbox_select, select_index, detail_method, detail_erode, detail_dilate, black_point, white_point, process_detail, max_megapixels
         */
        inputs?: {
            sam2_model: unknown;
            image: unknown;
            bboxes: unknown;
            bbox_select: string;
            select_index: string;
            detail_method: string;
            detail_erode: number;
            detail_dilate: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            max_megapixels: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__LoadSAM2Model {
        /**
         * INPUT_TYPES: sam2_model, precision, device
         */
        inputs?: {
            sam2_model: string;
            precision: string;
            device: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LS_SAM2_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__SaveImagePlusV2 {
        /**
         * INPUT_TYPES: images, custom_path, custom_filename, filename_prefix, timestamp, dpi, format, quality, meta_data, blind_watermark, save_workflow_as_json, preview
         */
        inputs?: {
            images: unknown;
            custom_path: string;
            custom_filename: string;
            filename_prefix: string;
            timestamp: string;
            dpi: number;
            format: string;
            quality: number;
            meta_data: unknown;
            blind_watermark: string;
            save_workflow_as_json: unknown;
            preview: unknown;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface LayerMask__SegmentAnythingUltra_V3 {
        /**
         * INPUT_TYPES: image, sam_models, threshold, detail_method, detail_erode, detail_dilate, black_point, white_point, process_detail, prompt, device, max_megapixels
         */
        inputs?: {
            image: unknown;
            sam_models: unknown;
            threshold: number;
            detail_method: string;
            detail_erode: number;
            detail_dilate: number;
            black_point: number;
            white_point: number;
            process_detail: unknown;
            prompt: string;
            device: string;
            max_megapixels: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface LayerMask__LoadSegmentAnythingModels {
        /**
         * INPUT_TYPES: sam_model, grounding_dino_model
         */
        inputs?: {
            sam_model: string;
            grounding_dino_model: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LS_SAM_MODELS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__LoadSmolLM2Model {
        /**
         * INPUT_TYPES: model, dtype, device
         */
        inputs?: {
            model: string;
            dtype: string;
            device: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SmolLM2_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__LoadSmolVLMModel {
        /**
         * INPUT_TYPES: model, dtype, device
         */
        inputs?: {
            model: string;
            dtype: string;
            device: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SmolVLM_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__SmolLM2 {
        /**
         * INPUT_TYPES: smolLM2_model, max_new_tokens, do_sample, temperature, top_p, system_prompt, user_prompt
         */
        inputs?: {
            smolLM2_model: unknown;
            max_new_tokens: number;
            do_sample: unknown;
            temperature: number;
            top_p: number;
            system_prompt: string;
            user_prompt: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__SmolVLM {
        /**
         * INPUT_TYPES: image, smolVLM_model, max_new_tokens, user_prompt
         */
        inputs?: {
            image: unknown;
            smolVLM_model: unknown;
            max_new_tokens: number;
            user_prompt: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ZhipuGLM4V {
        /**
         * INPUT_TYPES: image, model, user_prompt
         */
        inputs?: {
            image: unknown;
            model: string;
            user_prompt: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LayerUtility__ZhipuGLM4 {
        /**
         * INPUT_TYPES: model, user_prompt, history_length
         */
        inputs?: {
            model: string;
            user_prompt: string;
            history_length: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, GLM4_HISTORY
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface segformer_b2_clothes {
        /**
         * INPUT_TYPES: image, Face, Hat, Hair, Upper_clothes, Skirt, Pants, Dress, Belt, shoe, leg, arm, Bag, Scarf
         */
        inputs?: {
            image: unknown;
            Face: unknown;
            Hat: unknown;
            Hair: unknown;
            Upper_clothes: unknown;
            Skirt: unknown;
            Pants: unknown;
            Dress: unknown;
            Belt: unknown;
            shoe: unknown;
            leg: unknown;
            arm: unknown;
            Bag: unknown;
            Scarf: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface segformer_b3_fashion {
        /**
         * INPUT_TYPES: image, shirt, top, sweater, cardigan, jacket, vest, pants, shorts, skirt, coat, dress, jumpsuit, cape, glasses, hat, hairaccessory, tie, glove, watch, belt, legwarmer, tights, sock, shoe, bagwallet, scarf, umbrella, hood, collar, lapel, epaulette, sleeve, pocket, neckline, buckle, zipper, applique, bead, bow, flower, fringe, ribbon, rivet, ruffle, sequin, tassel
         */
        inputs?: {
            image: unknown;
            shirt: unknown;
            top: unknown;
            sweater: unknown;
            cardigan: unknown;
            jacket: unknown;
            vest: unknown;
            pants: unknown;
            shorts: unknown;
            skirt: unknown;
            coat: unknown;
            dress: unknown;
            jumpsuit: unknown;
            cape: unknown;
            glasses: unknown;
            hat: unknown;
            hairaccessory: unknown;
            tie: unknown;
            glove: unknown;
            watch: unknown;
            belt: unknown;
            legwarmer: unknown;
            tights: unknown;
            sock: unknown;
            shoe: unknown;
            bagwallet: unknown;
            scarf: unknown;
            umbrella: unknown;
            hood: unknown;
            collar: unknown;
            lapel: unknown;
            epaulette: unknown;
            sleeve: unknown;
            pocket: unknown;
            neckline: unknown;
            buckle: unknown;
            zipper: unknown;
            applique: unknown;
            bead: unknown;
            bow: unknown;
            flower: unknown;
            fringe: unknown;
            ribbon: unknown;
            rivet: unknown;
            ruffle: unknown;
            sequin: unknown;
            tassel: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface UltimateSDUpscale {
        /**
         * INPUT_TYPES: image, model, positive, negative, vae, upscale_by, seed, steps, cfg, sampler_name, scheduler, denoise, upscale_model, mode_type, tile_width, tile_height, mask_blur, tile_padding, seam_fix_mode, seam_fix_denoise, seam_fix_width, seam_fix_mask_blur, seam_fix_padding, force_uniform_tiles, tiled_decode
         */
        inputs?: {
            image: unknown;
            model: unknown;
            positive: unknown;
            negative: unknown;
            vae: unknown;
            upscale_by: number;
            seed: number;
            steps: number;
            cfg: number;
            sampler_name: string;
            scheduler: string;
            denoise: number;
            upscale_model: unknown;
            mode_type: string;
            tile_width: number;
            tile_height: number;
            mask_blur: number;
            tile_padding: number;
            seam_fix_mode: string;
            seam_fix_denoise: number;
            seam_fix_width: number;
            seam_fix_mask_blur: number;
            seam_fix_padding: number;
            force_uniform_tiles: unknown;
            tiled_decode: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface UltimateSDUpscaleNoUpscale {
        /**
         * INPUT_TYPES: upscaled_image, model, positive, negative, vae, seed, steps, cfg, sampler_name, scheduler, denoise, mode_type, tile_width, tile_height, mask_blur, tile_padding, seam_fix_mode, seam_fix_denoise, seam_fix_width, seam_fix_mask_blur, seam_fix_padding, force_uniform_tiles, tiled_decode
         */
        inputs?: {
            upscaled_image: unknown;
            model: unknown;
            positive: unknown;
            negative: unknown;
            vae: unknown;
            seed: number;
            steps: number;
            cfg: number;
            sampler_name: string;
            scheduler: string;
            denoise: number;
            mode_type: string;
            tile_width: number;
            tile_height: number;
            mask_blur: number;
            tile_padding: number;
            seam_fix_mode: string;
            seam_fix_denoise: number;
            seam_fix_width: number;
            seam_fix_mask_blur: number;
            seam_fix_padding: number;
            force_uniform_tiles: unknown;
            tiled_decode: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface UltimateSDUpscaleCustomSample {
        /**
         * INPUT_TYPES: image, model, positive, negative, vae, upscale_by, seed, steps, cfg, sampler_name, scheduler, denoise, mode_type, tile_width, tile_height, mask_blur, tile_padding, seam_fix_mode, seam_fix_denoise, seam_fix_width, seam_fix_mask_blur, seam_fix_padding, force_uniform_tiles, tiled_decode
         */
        inputs?: {
            image: unknown;
            model: unknown;
            positive: unknown;
            negative: unknown;
            vae: unknown;
            upscale_by: number;
            seed: number;
            steps: number;
            cfg: number;
            sampler_name: string;
            scheduler: string;
            denoise: number;
            mode_type: string;
            tile_width: number;
            tile_height: number;
            mask_blur: number;
            tile_padding: number;
            seam_fix_mode: string;
            seam_fix_denoise: number;
            seam_fix_width: number;
            seam_fix_mask_blur: number;
            seam_fix_padding: number;
            force_uniform_tiles: unknown;
            tiled_decode: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface KSampler__Efficient_ {
        /**
         * INPUT_TYPES: model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise, preview_method, vae_decode
         */
        inputs?: {
            model: unknown;
            seed: number;
            steps: number;
            cfg: number;
            sampler_name: string;
            scheduler: string;
            positive: unknown;
            negative: unknown;
            latent_image: unknown;
            denoise: number;
            preview_method: string;
            vae_decode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CONDITIONING, CONDITIONING, LATENT, VAE, IMAGE
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface KSampler_Adv___Efficient_ {
        /**
         * INPUT_TYPES: model, add_noise, noise_seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, start_at_step, end_at_step, return_with_leftover_noise, preview_method, vae_decode
         */
        inputs?: {
            model: unknown;
            add_noise: string;
            noise_seed: number;
            steps: number;
            cfg: number;
            sampler_name: string;
            scheduler: string;
            positive: unknown;
            negative: unknown;
            latent_image: unknown;
            start_at_step: number;
            end_at_step: number;
            return_with_leftover_noise: string;
            preview_method: string;
            vae_decode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CONDITIONING, CONDITIONING, LATENT, VAE, IMAGE
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface KSampler_SDXL__Eff__ {
        /**
         * INPUT_TYPES: sdxl_tuple, noise_seed, steps, cfg, sampler_name, scheduler, latent_image, start_at_step, refine_at_step, preview_method, vae_decode
         */
        inputs?: {
            sdxl_tuple: unknown;
            noise_seed: number;
            steps: number;
            cfg: number;
            sampler_name: string;
            scheduler: string;
            latent_image: unknown;
            start_at_step: number;
            refine_at_step: number;
            preview_method: string;
            vae_decode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SDXL_TUPLE, LATENT, VAE, IMAGE
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Efficient_Loader {
        /**
         * INPUT_TYPES: ckpt_name, vae_name, clip_skip, lora_name, lora_model_strength, lora_clip_strength, positive, negative, token_normalization, weight_interpretation, empty_latent_width, empty_latent_height, batch_size
         */
        inputs?: {
            ckpt_name: string;
            vae_name: string;
            clip_skip: number;
            lora_name: string;
            lora_model_strength: number;
            lora_clip_strength: number;
            positive: string;
            negative: string;
            token_normalization: string;
            weight_interpretation: string;
            empty_latent_width: number;
            empty_latent_height: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CONDITIONING, CONDITIONING, LATENT, VAE, CLIP, DEPENDENCIES
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Eff__Loader_SDXL {
        /**
         * INPUT_TYPES: base_ckpt_name, base_clip_skip, refiner_ckpt_name, refiner_clip_skip, positive_ascore, negative_ascore, vae_name, positive, negative, token_normalization, weight_interpretation, empty_latent_width, empty_latent_height, batch_size
         */
        inputs?: {
            base_ckpt_name: string;
            base_clip_skip: number;
            refiner_ckpt_name: string;
            refiner_clip_skip: number;
            positive_ascore: number;
            negative_ascore: number;
            vae_name: string;
            positive: string;
            negative: string;
            token_normalization: string;
            weight_interpretation: string;
            empty_latent_width: number;
            empty_latent_height: number;
            batch_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SDXL_TUPLE, LATENT, VAE, DEPENDENCIES
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface LoRA_Stacker {
        /**
         * INPUT_TYPES: input_mode, lora_count, lora_name_1, lora_wt_1, model_str_1, clip_str_1, lora_name_2, lora_wt_2, model_str_2, clip_str_2, lora_name_3, lora_wt_3, model_str_3, clip_str_3, lora_name_4, lora_wt_4, model_str_4, clip_str_4, lora_name_5, lora_wt_5, model_str_5, clip_str_5, lora_name_6, lora_wt_6, model_str_6, clip_str_6, lora_name_7, lora_wt_7, model_str_7, clip_str_7, lora_name_8, lora_wt_8, model_str_8, clip_str_8, lora_name_9, lora_wt_9, model_str_9, clip_str_9, lora_name_10, lora_wt_10, model_str_10, clip_str_10, lora_name_11, lora_wt_11, model_str_11, clip_str_11, lora_name_12, lora_wt_12, model_str_12, clip_str_12, lora_name_13, lora_wt_13, model_str_13, clip_str_13, lora_name_14, lora_wt_14, model_str_14, clip_str_14, lora_name_15, lora_wt_15, model_str_15, clip_str_15, lora_name_16, lora_wt_16, model_str_16, clip_str_16, lora_name_17, lora_wt_17, model_str_17, clip_str_17, lora_name_18, lora_wt_18, model_str_18, clip_str_18, lora_name_19, lora_wt_19, model_str_19, clip_str_19, lora_name_20, lora_wt_20, model_str_20, clip_str_20, lora_name_21, lora_wt_21, model_str_21, clip_str_21, lora_name_22, lora_wt_22, model_str_22, clip_str_22, lora_name_23, lora_wt_23, model_str_23, clip_str_23, lora_name_24, lora_wt_24, model_str_24, clip_str_24, lora_name_25, lora_wt_25, model_str_25, clip_str_25, lora_name_26, lora_wt_26, model_str_26, clip_str_26, lora_name_27, lora_wt_27, model_str_27, clip_str_27, lora_name_28, lora_wt_28, model_str_28, clip_str_28, lora_name_29, lora_wt_29, model_str_29, clip_str_29, lora_name_30, lora_wt_30, model_str_30, clip_str_30, lora_name_31, lora_wt_31, model_str_31, clip_str_31, lora_name_32, lora_wt_32, model_str_32, clip_str_32, lora_name_33, lora_wt_33, model_str_33, clip_str_33, lora_name_34, lora_wt_34, model_str_34, clip_str_34, lora_name_35, lora_wt_35, model_str_35, clip_str_35, lora_name_36, lora_wt_36, model_str_36, clip_str_36, lora_name_37, lora_wt_37, model_str_37, clip_str_37, lora_name_38, lora_wt_38, model_str_38, clip_str_38, lora_name_39, lora_wt_39, model_str_39, clip_str_39, lora_name_40, lora_wt_40, model_str_40, clip_str_40, lora_name_41, lora_wt_41, model_str_41, clip_str_41, lora_name_42, lora_wt_42, model_str_42, clip_str_42, lora_name_43, lora_wt_43, model_str_43, clip_str_43, lora_name_44, lora_wt_44, model_str_44, clip_str_44, lora_name_45, lora_wt_45, model_str_45, clip_str_45, lora_name_46, lora_wt_46, model_str_46, clip_str_46, lora_name_47, lora_wt_47, model_str_47, clip_str_47, lora_name_48, lora_wt_48, model_str_48, clip_str_48, lora_name_49, lora_wt_49, model_str_49, clip_str_49
         */
        inputs?: {
            input_mode: string;
            lora_count: number;
            lora_name_1: string;
            lora_wt_1: number;
            model_str_1: number;
            clip_str_1: number;
            lora_name_2: string;
            lora_wt_2: number;
            model_str_2: number;
            clip_str_2: number;
            lora_name_3: string;
            lora_wt_3: number;
            model_str_3: number;
            clip_str_3: number;
            lora_name_4: string;
            lora_wt_4: number;
            model_str_4: number;
            clip_str_4: number;
            lora_name_5: string;
            lora_wt_5: number;
            model_str_5: number;
            clip_str_5: number;
            lora_name_6: string;
            lora_wt_6: number;
            model_str_6: number;
            clip_str_6: number;
            lora_name_7: string;
            lora_wt_7: number;
            model_str_7: number;
            clip_str_7: number;
            lora_name_8: string;
            lora_wt_8: number;
            model_str_8: number;
            clip_str_8: number;
            lora_name_9: string;
            lora_wt_9: number;
            model_str_9: number;
            clip_str_9: number;
            lora_name_10: string;
            lora_wt_10: number;
            model_str_10: number;
            clip_str_10: number;
            lora_name_11: string;
            lora_wt_11: number;
            model_str_11: number;
            clip_str_11: number;
            lora_name_12: string;
            lora_wt_12: number;
            model_str_12: number;
            clip_str_12: number;
            lora_name_13: string;
            lora_wt_13: number;
            model_str_13: number;
            clip_str_13: number;
            lora_name_14: string;
            lora_wt_14: number;
            model_str_14: number;
            clip_str_14: number;
            lora_name_15: string;
            lora_wt_15: number;
            model_str_15: number;
            clip_str_15: number;
            lora_name_16: string;
            lora_wt_16: number;
            model_str_16: number;
            clip_str_16: number;
            lora_name_17: string;
            lora_wt_17: number;
            model_str_17: number;
            clip_str_17: number;
            lora_name_18: string;
            lora_wt_18: number;
            model_str_18: number;
            clip_str_18: number;
            lora_name_19: string;
            lora_wt_19: number;
            model_str_19: number;
            clip_str_19: number;
            lora_name_20: string;
            lora_wt_20: number;
            model_str_20: number;
            clip_str_20: number;
            lora_name_21: string;
            lora_wt_21: number;
            model_str_21: number;
            clip_str_21: number;
            lora_name_22: string;
            lora_wt_22: number;
            model_str_22: number;
            clip_str_22: number;
            lora_name_23: string;
            lora_wt_23: number;
            model_str_23: number;
            clip_str_23: number;
            lora_name_24: string;
            lora_wt_24: number;
            model_str_24: number;
            clip_str_24: number;
            lora_name_25: string;
            lora_wt_25: number;
            model_str_25: number;
            clip_str_25: number;
            lora_name_26: string;
            lora_wt_26: number;
            model_str_26: number;
            clip_str_26: number;
            lora_name_27: string;
            lora_wt_27: number;
            model_str_27: number;
            clip_str_27: number;
            lora_name_28: string;
            lora_wt_28: number;
            model_str_28: number;
            clip_str_28: number;
            lora_name_29: string;
            lora_wt_29: number;
            model_str_29: number;
            clip_str_29: number;
            lora_name_30: string;
            lora_wt_30: number;
            model_str_30: number;
            clip_str_30: number;
            lora_name_31: string;
            lora_wt_31: number;
            model_str_31: number;
            clip_str_31: number;
            lora_name_32: string;
            lora_wt_32: number;
            model_str_32: number;
            clip_str_32: number;
            lora_name_33: string;
            lora_wt_33: number;
            model_str_33: number;
            clip_str_33: number;
            lora_name_34: string;
            lora_wt_34: number;
            model_str_34: number;
            clip_str_34: number;
            lora_name_35: string;
            lora_wt_35: number;
            model_str_35: number;
            clip_str_35: number;
            lora_name_36: string;
            lora_wt_36: number;
            model_str_36: number;
            clip_str_36: number;
            lora_name_37: string;
            lora_wt_37: number;
            model_str_37: number;
            clip_str_37: number;
            lora_name_38: string;
            lora_wt_38: number;
            model_str_38: number;
            clip_str_38: number;
            lora_name_39: string;
            lora_wt_39: number;
            model_str_39: number;
            clip_str_39: number;
            lora_name_40: string;
            lora_wt_40: number;
            model_str_40: number;
            clip_str_40: number;
            lora_name_41: string;
            lora_wt_41: number;
            model_str_41: number;
            clip_str_41: number;
            lora_name_42: string;
            lora_wt_42: number;
            model_str_42: number;
            clip_str_42: number;
            lora_name_43: string;
            lora_wt_43: number;
            model_str_43: number;
            clip_str_43: number;
            lora_name_44: string;
            lora_wt_44: number;
            model_str_44: number;
            clip_str_44: number;
            lora_name_45: string;
            lora_wt_45: number;
            model_str_45: number;
            clip_str_45: number;
            lora_name_46: string;
            lora_wt_46: number;
            model_str_46: number;
            clip_str_46: number;
            lora_name_47: string;
            lora_wt_47: number;
            model_str_47: number;
            clip_str_47: number;
            lora_name_48: string;
            lora_wt_48: number;
            model_str_48: number;
            clip_str_48: number;
            lora_name_49: string;
            lora_wt_49: number;
            model_str_49: number;
            clip_str_49: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LORA_STACK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Control_Net_Stacker {
        /**
         * INPUT_TYPES: control_net, image, strength, start_percent, end_percent
         */
        inputs?: {
            control_net: unknown;
            image: unknown;
            strength: number;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET_STACK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Apply_ControlNet_Stack {
        /**
         * INPUT_TYPES: positive, negative
         */
        inputs?: {
            positive: unknown;
            negative: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Unpack_SDXL_Tuple {
        /**
         * INPUT_TYPES: sdxl_tuple
         */
        inputs?: {
            sdxl_tuple: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, CONDITIONING, CONDITIONING, MODEL, CLIP, CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Pack_SDXL_Tuple {
        /**
         * INPUT_TYPES: base_model, base_clip, base_positive, base_negative, refiner_model, refiner_clip, refiner_positive, refiner_negative
         */
        inputs?: {
            base_model: unknown;
            base_clip: unknown;
            base_positive: unknown;
            base_negative: unknown;
            refiner_model: unknown;
            refiner_clip: unknown;
            refiner_positive: unknown;
            refiner_negative: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SDXL_TUPLE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Plot {
        /**
         * INPUT_TYPES: grid_spacing, XY_flip, Y_label_orientation, cache_models, ksampler_output_image
         */
        inputs?: {
            grid_spacing: number;
            XY_flip: string;
            Y_label_orientation: string;
            cache_models: string;
            ksampler_output_image: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SCRIPT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Input__Seeds___Batch {
        /**
         * INPUT_TYPES: batch_count
         */
        inputs?: {
            batch_count: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Input__Add_Return_Noise {
        /**
         * INPUT_TYPES: XY_type
         */
        inputs?: {
            XY_type: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Input__Steps {
        /**
         * INPUT_TYPES: target_parameter, batch_count, first_step, last_step, first_start_step, last_start_step, first_end_step, last_end_step, first_refine_step, last_refine_step
         */
        inputs?: {
            target_parameter: string;
            batch_count: number;
            first_step: number;
            last_step: number;
            first_start_step: number;
            last_start_step: number;
            first_end_step: number;
            last_end_step: number;
            first_refine_step: number;
            last_refine_step: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Input__CFG_Scale {
        /**
         * INPUT_TYPES: batch_count, first_cfg, last_cfg
         */
        inputs?: {
            batch_count: number;
            first_cfg: number;
            last_cfg: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Input__Sampler_Scheduler {
        /**
         * INPUT_TYPES: target_parameter, input_count, sampler_1, scheduler_1, sampler_2, scheduler_2, sampler_3, scheduler_3, sampler_4, scheduler_4, sampler_5, scheduler_5, sampler_6, scheduler_6, sampler_7, scheduler_7, sampler_8, scheduler_8, sampler_9, scheduler_9, sampler_10, scheduler_10, sampler_11, scheduler_11, sampler_12, scheduler_12, sampler_13, scheduler_13, sampler_14, scheduler_14, sampler_15, scheduler_15, sampler_16, scheduler_16, sampler_17, scheduler_17, sampler_18, scheduler_18, sampler_19, scheduler_19, sampler_20, scheduler_20, sampler_21, scheduler_21, sampler_22, scheduler_22, sampler_23, scheduler_23, sampler_24, scheduler_24, sampler_25, scheduler_25, sampler_26, scheduler_26, sampler_27, scheduler_27, sampler_28, scheduler_28, sampler_29, scheduler_29, sampler_30, scheduler_30, sampler_31, scheduler_31, sampler_32, scheduler_32, sampler_33, scheduler_33, sampler_34, scheduler_34, sampler_35, scheduler_35, sampler_36, scheduler_36, sampler_37, scheduler_37, sampler_38, scheduler_38, sampler_39, scheduler_39, sampler_40, scheduler_40, sampler_41, scheduler_41, sampler_42, scheduler_42, sampler_43, scheduler_43, sampler_44, scheduler_44, sampler_45, scheduler_45, sampler_46, scheduler_46, sampler_47, scheduler_47, sampler_48, scheduler_48, sampler_49, scheduler_49, sampler_50, scheduler_50
         */
        inputs?: {
            target_parameter: string;
            input_count: number;
            sampler_1: string;
            scheduler_1: string;
            sampler_2: string;
            scheduler_2: string;
            sampler_3: string;
            scheduler_3: string;
            sampler_4: string;
            scheduler_4: string;
            sampler_5: string;
            scheduler_5: string;
            sampler_6: string;
            scheduler_6: string;
            sampler_7: string;
            scheduler_7: string;
            sampler_8: string;
            scheduler_8: string;
            sampler_9: string;
            scheduler_9: string;
            sampler_10: string;
            scheduler_10: string;
            sampler_11: string;
            scheduler_11: string;
            sampler_12: string;
            scheduler_12: string;
            sampler_13: string;
            scheduler_13: string;
            sampler_14: string;
            scheduler_14: string;
            sampler_15: string;
            scheduler_15: string;
            sampler_16: string;
            scheduler_16: string;
            sampler_17: string;
            scheduler_17: string;
            sampler_18: string;
            scheduler_18: string;
            sampler_19: string;
            scheduler_19: string;
            sampler_20: string;
            scheduler_20: string;
            sampler_21: string;
            scheduler_21: string;
            sampler_22: string;
            scheduler_22: string;
            sampler_23: string;
            scheduler_23: string;
            sampler_24: string;
            scheduler_24: string;
            sampler_25: string;
            scheduler_25: string;
            sampler_26: string;
            scheduler_26: string;
            sampler_27: string;
            scheduler_27: string;
            sampler_28: string;
            scheduler_28: string;
            sampler_29: string;
            scheduler_29: string;
            sampler_30: string;
            scheduler_30: string;
            sampler_31: string;
            scheduler_31: string;
            sampler_32: string;
            scheduler_32: string;
            sampler_33: string;
            scheduler_33: string;
            sampler_34: string;
            scheduler_34: string;
            sampler_35: string;
            scheduler_35: string;
            sampler_36: string;
            scheduler_36: string;
            sampler_37: string;
            scheduler_37: string;
            sampler_38: string;
            scheduler_38: string;
            sampler_39: string;
            scheduler_39: string;
            sampler_40: string;
            scheduler_40: string;
            sampler_41: string;
            scheduler_41: string;
            sampler_42: string;
            scheduler_42: string;
            sampler_43: string;
            scheduler_43: string;
            sampler_44: string;
            scheduler_44: string;
            sampler_45: string;
            scheduler_45: string;
            sampler_46: string;
            scheduler_46: string;
            sampler_47: string;
            scheduler_47: string;
            sampler_48: string;
            scheduler_48: string;
            sampler_49: string;
            scheduler_49: string;
            sampler_50: string;
            scheduler_50: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Input__Denoise {
        /**
         * INPUT_TYPES: batch_count, first_denoise, last_denoise
         */
        inputs?: {
            batch_count: number;
            first_denoise: number;
            last_denoise: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Input__VAE {
        /**
         * INPUT_TYPES: input_mode, batch_path, subdirectories, batch_sort, batch_max, vae_count, vae_name_1, vae_name_2, vae_name_3, vae_name_4, vae_name_5, vae_name_6, vae_name_7, vae_name_8, vae_name_9, vae_name_10, vae_name_11, vae_name_12, vae_name_13, vae_name_14, vae_name_15, vae_name_16, vae_name_17, vae_name_18, vae_name_19, vae_name_20, vae_name_21, vae_name_22, vae_name_23, vae_name_24, vae_name_25, vae_name_26, vae_name_27, vae_name_28, vae_name_29, vae_name_30, vae_name_31, vae_name_32, vae_name_33, vae_name_34, vae_name_35, vae_name_36, vae_name_37, vae_name_38, vae_name_39, vae_name_40, vae_name_41, vae_name_42, vae_name_43, vae_name_44, vae_name_45, vae_name_46, vae_name_47, vae_name_48, vae_name_49, vae_name_50
         */
        inputs?: {
            input_mode: string;
            batch_path: string;
            subdirectories: unknown;
            batch_sort: string;
            batch_max: number;
            vae_count: number;
            vae_name_1: string;
            vae_name_2: string;
            vae_name_3: string;
            vae_name_4: string;
            vae_name_5: string;
            vae_name_6: string;
            vae_name_7: string;
            vae_name_8: string;
            vae_name_9: string;
            vae_name_10: string;
            vae_name_11: string;
            vae_name_12: string;
            vae_name_13: string;
            vae_name_14: string;
            vae_name_15: string;
            vae_name_16: string;
            vae_name_17: string;
            vae_name_18: string;
            vae_name_19: string;
            vae_name_20: string;
            vae_name_21: string;
            vae_name_22: string;
            vae_name_23: string;
            vae_name_24: string;
            vae_name_25: string;
            vae_name_26: string;
            vae_name_27: string;
            vae_name_28: string;
            vae_name_29: string;
            vae_name_30: string;
            vae_name_31: string;
            vae_name_32: string;
            vae_name_33: string;
            vae_name_34: string;
            vae_name_35: string;
            vae_name_36: string;
            vae_name_37: string;
            vae_name_38: string;
            vae_name_39: string;
            vae_name_40: string;
            vae_name_41: string;
            vae_name_42: string;
            vae_name_43: string;
            vae_name_44: string;
            vae_name_45: string;
            vae_name_46: string;
            vae_name_47: string;
            vae_name_48: string;
            vae_name_49: string;
            vae_name_50: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Input__Prompt_S_R {
        /**
         * INPUT_TYPES: target_prompt, search_txt, replace_count, replace_1, replace_2, replace_3, replace_4, replace_5, replace_6, replace_7, replace_8, replace_9, replace_10, replace_11, replace_12, replace_13, replace_14, replace_15, replace_16, replace_17, replace_18, replace_19, replace_20, replace_21, replace_22, replace_23, replace_24, replace_25, replace_26, replace_27, replace_28, replace_29, replace_30, replace_31, replace_32, replace_33, replace_34, replace_35, replace_36, replace_37, replace_38, replace_39, replace_40, replace_41, replace_42, replace_43, replace_44, replace_45, replace_46, replace_47, replace_48, replace_49
         */
        inputs?: {
            target_prompt: string;
            search_txt: string;
            replace_count: number;
            replace_1: string;
            replace_2: string;
            replace_3: string;
            replace_4: string;
            replace_5: string;
            replace_6: string;
            replace_7: string;
            replace_8: string;
            replace_9: string;
            replace_10: string;
            replace_11: string;
            replace_12: string;
            replace_13: string;
            replace_14: string;
            replace_15: string;
            replace_16: string;
            replace_17: string;
            replace_18: string;
            replace_19: string;
            replace_20: string;
            replace_21: string;
            replace_22: string;
            replace_23: string;
            replace_24: string;
            replace_25: string;
            replace_26: string;
            replace_27: string;
            replace_28: string;
            replace_29: string;
            replace_30: string;
            replace_31: string;
            replace_32: string;
            replace_33: string;
            replace_34: string;
            replace_35: string;
            replace_36: string;
            replace_37: string;
            replace_38: string;
            replace_39: string;
            replace_40: string;
            replace_41: string;
            replace_42: string;
            replace_43: string;
            replace_44: string;
            replace_45: string;
            replace_46: string;
            replace_47: string;
            replace_48: string;
            replace_49: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Input__Aesthetic_Score {
        /**
         * INPUT_TYPES: target_ascore, batch_count, first_ascore, last_ascore
         */
        inputs?: {
            target_ascore: string;
            batch_count: number;
            first_ascore: number;
            last_ascore: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Input__Refiner_On_Off {
        /**
         * INPUT_TYPES: refine_at_percent
         */
        inputs?: {
            refine_at_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Input__Checkpoint {
        /**
         * INPUT_TYPES: target_ckpt, input_mode, batch_path, subdirectories, batch_sort, batch_max, ckpt_count, ckpt_name_1, clip_skip_1, vae_name_1, ckpt_name_2, clip_skip_2, vae_name_2, ckpt_name_3, clip_skip_3, vae_name_3, ckpt_name_4, clip_skip_4, vae_name_4, ckpt_name_5, clip_skip_5, vae_name_5, ckpt_name_6, clip_skip_6, vae_name_6, ckpt_name_7, clip_skip_7, vae_name_7, ckpt_name_8, clip_skip_8, vae_name_8, ckpt_name_9, clip_skip_9, vae_name_9, ckpt_name_10, clip_skip_10, vae_name_10, ckpt_name_11, clip_skip_11, vae_name_11, ckpt_name_12, clip_skip_12, vae_name_12, ckpt_name_13, clip_skip_13, vae_name_13, ckpt_name_14, clip_skip_14, vae_name_14, ckpt_name_15, clip_skip_15, vae_name_15, ckpt_name_16, clip_skip_16, vae_name_16, ckpt_name_17, clip_skip_17, vae_name_17, ckpt_name_18, clip_skip_18, vae_name_18, ckpt_name_19, clip_skip_19, vae_name_19, ckpt_name_20, clip_skip_20, vae_name_20, ckpt_name_21, clip_skip_21, vae_name_21, ckpt_name_22, clip_skip_22, vae_name_22, ckpt_name_23, clip_skip_23, vae_name_23, ckpt_name_24, clip_skip_24, vae_name_24, ckpt_name_25, clip_skip_25, vae_name_25, ckpt_name_26, clip_skip_26, vae_name_26, ckpt_name_27, clip_skip_27, vae_name_27, ckpt_name_28, clip_skip_28, vae_name_28, ckpt_name_29, clip_skip_29, vae_name_29, ckpt_name_30, clip_skip_30, vae_name_30, ckpt_name_31, clip_skip_31, vae_name_31, ckpt_name_32, clip_skip_32, vae_name_32, ckpt_name_33, clip_skip_33, vae_name_33, ckpt_name_34, clip_skip_34, vae_name_34, ckpt_name_35, clip_skip_35, vae_name_35, ckpt_name_36, clip_skip_36, vae_name_36, ckpt_name_37, clip_skip_37, vae_name_37, ckpt_name_38, clip_skip_38, vae_name_38, ckpt_name_39, clip_skip_39, vae_name_39, ckpt_name_40, clip_skip_40, vae_name_40, ckpt_name_41, clip_skip_41, vae_name_41, ckpt_name_42, clip_skip_42, vae_name_42, ckpt_name_43, clip_skip_43, vae_name_43, ckpt_name_44, clip_skip_44, vae_name_44, ckpt_name_45, clip_skip_45, vae_name_45, ckpt_name_46, clip_skip_46, vae_name_46, ckpt_name_47, clip_skip_47, vae_name_47, ckpt_name_48, clip_skip_48, vae_name_48, ckpt_name_49, clip_skip_49, vae_name_49, ckpt_name_50, clip_skip_50, vae_name_50
         */
        inputs?: {
            target_ckpt: string;
            input_mode: string;
            batch_path: string;
            subdirectories: unknown;
            batch_sort: string;
            batch_max: number;
            ckpt_count: number;
            ckpt_name_1: string;
            clip_skip_1: number;
            vae_name_1: string;
            ckpt_name_2: string;
            clip_skip_2: number;
            vae_name_2: string;
            ckpt_name_3: string;
            clip_skip_3: number;
            vae_name_3: string;
            ckpt_name_4: string;
            clip_skip_4: number;
            vae_name_4: string;
            ckpt_name_5: string;
            clip_skip_5: number;
            vae_name_5: string;
            ckpt_name_6: string;
            clip_skip_6: number;
            vae_name_6: string;
            ckpt_name_7: string;
            clip_skip_7: number;
            vae_name_7: string;
            ckpt_name_8: string;
            clip_skip_8: number;
            vae_name_8: string;
            ckpt_name_9: string;
            clip_skip_9: number;
            vae_name_9: string;
            ckpt_name_10: string;
            clip_skip_10: number;
            vae_name_10: string;
            ckpt_name_11: string;
            clip_skip_11: number;
            vae_name_11: string;
            ckpt_name_12: string;
            clip_skip_12: number;
            vae_name_12: string;
            ckpt_name_13: string;
            clip_skip_13: number;
            vae_name_13: string;
            ckpt_name_14: string;
            clip_skip_14: number;
            vae_name_14: string;
            ckpt_name_15: string;
            clip_skip_15: number;
            vae_name_15: string;
            ckpt_name_16: string;
            clip_skip_16: number;
            vae_name_16: string;
            ckpt_name_17: string;
            clip_skip_17: number;
            vae_name_17: string;
            ckpt_name_18: string;
            clip_skip_18: number;
            vae_name_18: string;
            ckpt_name_19: string;
            clip_skip_19: number;
            vae_name_19: string;
            ckpt_name_20: string;
            clip_skip_20: number;
            vae_name_20: string;
            ckpt_name_21: string;
            clip_skip_21: number;
            vae_name_21: string;
            ckpt_name_22: string;
            clip_skip_22: number;
            vae_name_22: string;
            ckpt_name_23: string;
            clip_skip_23: number;
            vae_name_23: string;
            ckpt_name_24: string;
            clip_skip_24: number;
            vae_name_24: string;
            ckpt_name_25: string;
            clip_skip_25: number;
            vae_name_25: string;
            ckpt_name_26: string;
            clip_skip_26: number;
            vae_name_26: string;
            ckpt_name_27: string;
            clip_skip_27: number;
            vae_name_27: string;
            ckpt_name_28: string;
            clip_skip_28: number;
            vae_name_28: string;
            ckpt_name_29: string;
            clip_skip_29: number;
            vae_name_29: string;
            ckpt_name_30: string;
            clip_skip_30: number;
            vae_name_30: string;
            ckpt_name_31: string;
            clip_skip_31: number;
            vae_name_31: string;
            ckpt_name_32: string;
            clip_skip_32: number;
            vae_name_32: string;
            ckpt_name_33: string;
            clip_skip_33: number;
            vae_name_33: string;
            ckpt_name_34: string;
            clip_skip_34: number;
            vae_name_34: string;
            ckpt_name_35: string;
            clip_skip_35: number;
            vae_name_35: string;
            ckpt_name_36: string;
            clip_skip_36: number;
            vae_name_36: string;
            ckpt_name_37: string;
            clip_skip_37: number;
            vae_name_37: string;
            ckpt_name_38: string;
            clip_skip_38: number;
            vae_name_38: string;
            ckpt_name_39: string;
            clip_skip_39: number;
            vae_name_39: string;
            ckpt_name_40: string;
            clip_skip_40: number;
            vae_name_40: string;
            ckpt_name_41: string;
            clip_skip_41: number;
            vae_name_41: string;
            ckpt_name_42: string;
            clip_skip_42: number;
            vae_name_42: string;
            ckpt_name_43: string;
            clip_skip_43: number;
            vae_name_43: string;
            ckpt_name_44: string;
            clip_skip_44: number;
            vae_name_44: string;
            ckpt_name_45: string;
            clip_skip_45: number;
            vae_name_45: string;
            ckpt_name_46: string;
            clip_skip_46: number;
            vae_name_46: string;
            ckpt_name_47: string;
            clip_skip_47: number;
            vae_name_47: string;
            ckpt_name_48: string;
            clip_skip_48: number;
            vae_name_48: string;
            ckpt_name_49: string;
            clip_skip_49: number;
            vae_name_49: string;
            ckpt_name_50: string;
            clip_skip_50: number;
            vae_name_50: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Input__Clip_Skip {
        /**
         * INPUT_TYPES: target_ckpt, batch_count, first_clip_skip, last_clip_skip
         */
        inputs?: {
            target_ckpt: string;
            batch_count: number;
            first_clip_skip: number;
            last_clip_skip: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Input__LoRA {
        /**
         * INPUT_TYPES: input_mode, batch_path, subdirectories, batch_sort, batch_max, lora_count, model_strength, clip_strength, lora_name_1, model_str_1, clip_str_1, lora_name_2, model_str_2, clip_str_2, lora_name_3, model_str_3, clip_str_3, lora_name_4, model_str_4, clip_str_4, lora_name_5, model_str_5, clip_str_5, lora_name_6, model_str_6, clip_str_6, lora_name_7, model_str_7, clip_str_7, lora_name_8, model_str_8, clip_str_8, lora_name_9, model_str_9, clip_str_9, lora_name_10, model_str_10, clip_str_10, lora_name_11, model_str_11, clip_str_11, lora_name_12, model_str_12, clip_str_12, lora_name_13, model_str_13, clip_str_13, lora_name_14, model_str_14, clip_str_14, lora_name_15, model_str_15, clip_str_15, lora_name_16, model_str_16, clip_str_16, lora_name_17, model_str_17, clip_str_17, lora_name_18, model_str_18, clip_str_18, lora_name_19, model_str_19, clip_str_19, lora_name_20, model_str_20, clip_str_20, lora_name_21, model_str_21, clip_str_21, lora_name_22, model_str_22, clip_str_22, lora_name_23, model_str_23, clip_str_23, lora_name_24, model_str_24, clip_str_24, lora_name_25, model_str_25, clip_str_25, lora_name_26, model_str_26, clip_str_26, lora_name_27, model_str_27, clip_str_27, lora_name_28, model_str_28, clip_str_28, lora_name_29, model_str_29, clip_str_29, lora_name_30, model_str_30, clip_str_30, lora_name_31, model_str_31, clip_str_31, lora_name_32, model_str_32, clip_str_32, lora_name_33, model_str_33, clip_str_33, lora_name_34, model_str_34, clip_str_34, lora_name_35, model_str_35, clip_str_35, lora_name_36, model_str_36, clip_str_36, lora_name_37, model_str_37, clip_str_37, lora_name_38, model_str_38, clip_str_38, lora_name_39, model_str_39, clip_str_39, lora_name_40, model_str_40, clip_str_40, lora_name_41, model_str_41, clip_str_41, lora_name_42, model_str_42, clip_str_42, lora_name_43, model_str_43, clip_str_43, lora_name_44, model_str_44, clip_str_44, lora_name_45, model_str_45, clip_str_45, lora_name_46, model_str_46, clip_str_46, lora_name_47, model_str_47, clip_str_47, lora_name_48, model_str_48, clip_str_48, lora_name_49, model_str_49, clip_str_49, lora_name_50, model_str_50, clip_str_50
         */
        inputs?: {
            input_mode: string;
            batch_path: string;
            subdirectories: unknown;
            batch_sort: string;
            batch_max: number;
            lora_count: number;
            model_strength: number;
            clip_strength: number;
            lora_name_1: string;
            model_str_1: number;
            clip_str_1: number;
            lora_name_2: string;
            model_str_2: number;
            clip_str_2: number;
            lora_name_3: string;
            model_str_3: number;
            clip_str_3: number;
            lora_name_4: string;
            model_str_4: number;
            clip_str_4: number;
            lora_name_5: string;
            model_str_5: number;
            clip_str_5: number;
            lora_name_6: string;
            model_str_6: number;
            clip_str_6: number;
            lora_name_7: string;
            model_str_7: number;
            clip_str_7: number;
            lora_name_8: string;
            model_str_8: number;
            clip_str_8: number;
            lora_name_9: string;
            model_str_9: number;
            clip_str_9: number;
            lora_name_10: string;
            model_str_10: number;
            clip_str_10: number;
            lora_name_11: string;
            model_str_11: number;
            clip_str_11: number;
            lora_name_12: string;
            model_str_12: number;
            clip_str_12: number;
            lora_name_13: string;
            model_str_13: number;
            clip_str_13: number;
            lora_name_14: string;
            model_str_14: number;
            clip_str_14: number;
            lora_name_15: string;
            model_str_15: number;
            clip_str_15: number;
            lora_name_16: string;
            model_str_16: number;
            clip_str_16: number;
            lora_name_17: string;
            model_str_17: number;
            clip_str_17: number;
            lora_name_18: string;
            model_str_18: number;
            clip_str_18: number;
            lora_name_19: string;
            model_str_19: number;
            clip_str_19: number;
            lora_name_20: string;
            model_str_20: number;
            clip_str_20: number;
            lora_name_21: string;
            model_str_21: number;
            clip_str_21: number;
            lora_name_22: string;
            model_str_22: number;
            clip_str_22: number;
            lora_name_23: string;
            model_str_23: number;
            clip_str_23: number;
            lora_name_24: string;
            model_str_24: number;
            clip_str_24: number;
            lora_name_25: string;
            model_str_25: number;
            clip_str_25: number;
            lora_name_26: string;
            model_str_26: number;
            clip_str_26: number;
            lora_name_27: string;
            model_str_27: number;
            clip_str_27: number;
            lora_name_28: string;
            model_str_28: number;
            clip_str_28: number;
            lora_name_29: string;
            model_str_29: number;
            clip_str_29: number;
            lora_name_30: string;
            model_str_30: number;
            clip_str_30: number;
            lora_name_31: string;
            model_str_31: number;
            clip_str_31: number;
            lora_name_32: string;
            model_str_32: number;
            clip_str_32: number;
            lora_name_33: string;
            model_str_33: number;
            clip_str_33: number;
            lora_name_34: string;
            model_str_34: number;
            clip_str_34: number;
            lora_name_35: string;
            model_str_35: number;
            clip_str_35: number;
            lora_name_36: string;
            model_str_36: number;
            clip_str_36: number;
            lora_name_37: string;
            model_str_37: number;
            clip_str_37: number;
            lora_name_38: string;
            model_str_38: number;
            clip_str_38: number;
            lora_name_39: string;
            model_str_39: number;
            clip_str_39: number;
            lora_name_40: string;
            model_str_40: number;
            clip_str_40: number;
            lora_name_41: string;
            model_str_41: number;
            clip_str_41: number;
            lora_name_42: string;
            model_str_42: number;
            clip_str_42: number;
            lora_name_43: string;
            model_str_43: number;
            clip_str_43: number;
            lora_name_44: string;
            model_str_44: number;
            clip_str_44: number;
            lora_name_45: string;
            model_str_45: number;
            clip_str_45: number;
            lora_name_46: string;
            model_str_46: number;
            clip_str_46: number;
            lora_name_47: string;
            model_str_47: number;
            clip_str_47: number;
            lora_name_48: string;
            model_str_48: number;
            clip_str_48: number;
            lora_name_49: string;
            model_str_49: number;
            clip_str_49: number;
            lora_name_50: string;
            model_str_50: number;
            clip_str_50: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Input__LoRA_Plot {
        /**
         * INPUT_TYPES: input_mode, lora_name, model_strength, clip_strength, X_batch_count, X_batch_path, X_subdirectories, X_batch_sort, X_first_value, X_last_value, Y_batch_count, Y_first_value, Y_last_value
         */
        inputs?: {
            input_mode: string;
            lora_name: string;
            model_strength: number;
            clip_strength: number;
            X_batch_count: number;
            X_batch_path: string;
            X_subdirectories: unknown;
            X_batch_sort: string;
            X_first_value: number;
            X_last_value: number;
            Y_batch_count: number;
            Y_first_value: number;
            Y_last_value: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY, XY
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface XY_Input__LoRA_Stacks {
        /**
         * INPUT_TYPES: node_state
         */
        inputs?: {
            node_state: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Input__Control_Net {
        /**
         * INPUT_TYPES: control_net, image, target_parameter, batch_count, first_strength, last_strength, first_start_percent, last_start_percent, first_end_percent, last_end_percent, strength, start_percent, end_percent
         */
        inputs?: {
            control_net: unknown;
            image: unknown;
            target_parameter: string;
            batch_count: number;
            first_strength: number;
            last_strength: number;
            first_start_percent: number;
            last_start_percent: number;
            first_end_percent: number;
            last_end_percent: number;
            strength: number;
            start_percent: number;
            end_percent: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface XY_Input__Control_Net_Plot {
        /**
         * INPUT_TYPES: control_net, image, plot_type, strength, start_percent, end_percent, X_batch_count, X_first_value, X_last_value, Y_batch_count, Y_first_value, Y_last_value
         */
        inputs?: {
            control_net: unknown;
            image: unknown;
            plot_type: string;
            strength: number;
            start_percent: number;
            end_percent: number;
            X_batch_count: number;
            X_first_value: number;
            X_last_value: number;
            Y_batch_count: number;
            Y_first_value: number;
            Y_last_value: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY, XY
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface XY_Input__Manual_XY_Entry {
        /**
         * INPUT_TYPES: plot_type, plot_value
         */
        inputs?: {
            plot_type: string;
            plot_value: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Join_XY_Inputs_of_Same_Type {
        /**
         * INPUT_TYPES: XY_1, XY_2
         */
        inputs?: {
            XY_1: unknown;
            XY_2: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: XY
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Overlay {
        /**
         * INPUT_TYPES: base_image, overlay_image, overlay_resize, resize_method, rescale_factor, width, height, x_offset, y_offset, rotation, opacity
         */
        inputs?: {
            base_image: unknown;
            overlay_image: unknown;
            overlay_resize: string;
            resize_method: string;
            rescale_factor: number;
            width: number;
            height: number;
            x_offset: number;
            y_offset: number;
            rotation: number;
            opacity: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Noise_Control_Script {
        /**
         * INPUT_TYPES: rng_source, cfg_denoiser, add_seed_noise, seed, weight
         */
        inputs?: {
            rng_source: string;
            cfg_denoiser: unknown;
            add_seed_noise: unknown;
            seed: number;
            weight: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SCRIPT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface HighRes_Fix_Script {
        /**
         * INPUT_TYPES: upscale_type, hires_ckpt_name, latent_upscaler, pixel_upscaler, upscale_by, use_same_seed, seed, hires_steps, denoise, iterations, use_controlnet, control_net_name, strength, preprocessor, preprocessor_imgs
         */
        inputs?: {
            upscale_type: string;
            hires_ckpt_name: string;
            latent_upscaler: string;
            pixel_upscaler: string;
            upscale_by: number;
            use_same_seed: unknown;
            seed: number;
            hires_steps: number;
            denoise: number;
            iterations: number;
            use_controlnet: unknown;
            control_net_name: string;
            strength: number;
            preprocessor: string;
            preprocessor_imgs: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SCRIPT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Tiled_Upscaler_Script {
        /**
         * INPUT_TYPES: upscale_by, tile_size, tiling_strategy, tiling_steps, seed, denoise, use_controlnet, tile_controlnet, strength
         */
        inputs?: {
            upscale_by: number;
            tile_size: number;
            tiling_strategy: string;
            tiling_steps: number;
            seed: number;
            denoise: number;
            use_controlnet: unknown;
            tile_controlnet: string;
            strength: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SCRIPT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LoRA_Stack_to_String_converter {
        /**
         * INPUT_TYPES: lora_stack
         */
        inputs?: {
            lora_stack: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Evaluate_Integers {
        /**
         * INPUT_TYPES: python_expression, print_to_console
         */
        inputs?: {
            python_expression: string;
            print_to_console: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, FLOAT, STRING
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Evaluate_Floats {
        /**
         * INPUT_TYPES: python_expression, print_to_console
         */
        inputs?: {
            python_expression: string;
            print_to_console: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, FLOAT, STRING
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Evaluate_Strings {
        /**
         * INPUT_TYPES: python_expression, print_to_console
         */
        inputs?: {
            python_expression: string;
            print_to_console: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LoaderGGUF {
        /**
         * INPUT_TYPES: gguf_name
         */
        inputs?: {
            gguf_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface ClipLoaderGGUF {
        /**
         * INPUT_TYPES: clip_name, type
         */
        inputs?: {
            clip_name: string;
            type: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface DualClipLoaderGGUF {
        /**
         * INPUT_TYPES: clip_name1, clip_name2, type
         */
        inputs?: {
            clip_name1: string;
            clip_name2: string;
            type: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface TripleClipLoaderGGUF {
        /**
         * INPUT_TYPES: clip_name1, clip_name2, clip_name3
         */
        inputs?: {
            clip_name1: string;
            clip_name2: string;
            clip_name3: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface QuadrupleClipLoaderGGUF {
        /**
         * INPUT_TYPES: clip_name1, clip_name2, clip_name3, clip_name4
         */
        inputs?: {
            clip_name1: string;
            clip_name2: string;
            clip_name3: string;
            clip_name4: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface AudioEncoderLoaderGGUF {
        /**
         * INPUT_TYPES: audio_encoder_name
         */
        inputs?: {
            audio_encoder_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: AUDIO_ENCODER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface LoaderGGUFAdvanced {
        /**
         * INPUT_TYPES: gguf_name, dequant_dtype, patch_dtype, patch_on_device
         */
        inputs?: {
            gguf_name: string;
            dequant_dtype: string;
            patch_dtype: string;
            patch_on_device: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface VaeGGUF {
        /**
         * INPUT_TYPES: vae_name
         */
        inputs?: {
            vae_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: VAE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface GGUFUndo {
        /**
         * INPUT_TYPES: select_gguf
         */
        inputs?: {
            select_gguf: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface GGUFSave {
        /**
         * INPUT_TYPES: select_safetensors
         */
        inputs?: {
            select_safetensors: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface GGUFRun {
        /**
         * INPUT_TYPES: select_safetensors
         */
        inputs?: {
            select_safetensors: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface TENSORCut {
        /**
         * INPUT_TYPES: select_safetensors
         */
        inputs?: {
            select_safetensors: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface TENSORBoost {
        /**
         * INPUT_TYPES: select_safetensors
         */
        inputs?: {
            select_safetensors: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface InContextEditInstruction {
        /**
         * INPUT_TYPES: editText, clip
         */
        inputs?: {
            editText: string;
            clip: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface DiptychCreate {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, IMAGE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface ICEFConditioning {
        /**
         * INPUT_TYPES: In_context, negative, vae, diptych, maskDiptych
         */
        inputs?: {
            In_context: unknown;
            negative: unknown;
            vae: unknown;
            diptych: unknown;
            maskDiptych: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, CONDITIONING, LATENT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Mask_By_Text {
        /**
         * INPUT_TYPES: image, prompt, negative_prompt, precision, normalize
         */
        inputs?: {
            image: unknown;
            prompt: string;
            negative_prompt: string;
            precision: number;
            normalize: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Mask_Morphology {
        /**
         * INPUT_TYPES: image, distance, op
         */
        inputs?: {
            image: unknown;
            distance: number;
            op: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Combine_Masks {
        /**
         * INPUT_TYPES: image1, image2, op, clamp_result, round_result
         */
        inputs?: {
            image1: unknown;
            image2: unknown;
            op: string;
            clamp_result: string;
            round_result: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Unary_Mask_Op {
        /**
         * INPUT_TYPES: image, op
         */
        inputs?: {
            image: unknown;
            op: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Unary_Image_Op {
        /**
         * INPUT_TYPES: image, op
         */
        inputs?: {
            image: unknown;
            op: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Blur {
        /**
         * INPUT_TYPES: image, radius, sigma_factor
         */
        inputs?: {
            image: unknown;
            radius: number;
            sigma_factor: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_To_Mask {
        /**
         * INPUT_TYPES: image, method
         */
        inputs?: {
            image: unknown;
            method: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mix_Images_By_Mask {
        /**
         * INPUT_TYPES: image1, image2, mask
         */
        inputs?: {
            image1: unknown;
            image2: unknown;
            mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mix_Color_By_Mask {
        /**
         * INPUT_TYPES: image, r, g, b, mask
         */
        inputs?: {
            image: unknown;
            r: number;
            g: number;
            b: number;
            mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_To_Region {
        /**
         * INPUT_TYPES: mask, padding, constraints, constraint_x, constraint_y, min_width, min_height, batch_behavior
         */
        inputs?: {
            mask: unknown;
            padding: number;
            constraints: string;
            constraint_x: number;
            constraint_y: number;
            min_width: number;
            min_height: number;
            batch_behavior: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Cut_By_Mask {
        /**
         * INPUT_TYPES: image, mask, force_resize_width, force_resize_height
         */
        inputs?: {
            image: unknown;
            mask: unknown;
            force_resize_width: number;
            force_resize_height: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Paste_By_Mask {
        /**
         * INPUT_TYPES: image_base, image_to_paste, mask, resize_behavior
         */
        inputs?: {
            image_base: unknown;
            image_to_paste: unknown;
            mask: unknown;
            resize_behavior: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Get_Image_Size {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, INT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Change_Channel_Count {
        /**
         * INPUT_TYPES: image, kind
         */
        inputs?: {
            image: unknown;
            kind: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Constant_Mask {
        /**
         * INPUT_TYPES: value, explicit_height, explicit_width
         */
        inputs?: {
            value: number;
            explicit_height: number;
            explicit_width: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Prune_By_Mask {
        /**
         * INPUT_TYPES: image, mask
         */
        inputs?: {
            image: unknown;
            mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Separate_Mask_Components {
        /**
         * INPUT_TYPES: mask
         */
        inputs?: {
            mask: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK_MAPPING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Create_Rect_Mask {
        /**
         * INPUT_TYPES: mode, origin, x, y, width, height, image_width, image_height
         */
        inputs?: {
            mode: string;
            origin: string;
            x: number;
            y: number;
            width: number;
            height: number;
            image_width: number;
            image_height: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Make_Image_Batch {
        /**
         * INPUT_TYPES: image1
         */
        inputs?: {
            image1: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Create_QR_Code {
        /**
         * INPUT_TYPES: text, size, qr_version, error_correction, box_size, border
         */
        inputs?: {
            text: string;
            size: number;
            qr_version: number;
            error_correction: string;
            box_size: number;
            border: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Convert_Color_Space {
        /**
         * INPUT_TYPES: in_space, out_space, image
         */
        inputs?: {
            in_space: string;
            out_space: string;
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MasqueradeIncrementer {
        /**
         * INPUT_TYPES: seed, max_value
         */
        inputs?: {
            seed: number;
            max_value: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface BLIP_Model_Loader {
        /**
         * INPUT_TYPES: blip_model, vqa_model_id, device
         */
        inputs?: {
            blip_model: string;
            vqa_model_id: string;
            device: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BLIP_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Blend_Latents {
        /**
         * INPUT_TYPES: latent_a, latent_b, operation, blend
         */
        inputs?: {
            latent_a: unknown;
            latent_b: unknown;
            operation: string;
            blend: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Bus_Node {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BUS, MODEL, CLIP, VAE, CONDITIONING, CONDITIONING
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Cache_Node {
        /**
         * INPUT_TYPES: latent_suffix, image_suffix, conditioning_suffix
         */
        inputs?: {
            latent_suffix: string;
            image_suffix: string;
            conditioning_suffix: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, STRING, STRING
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Checkpoint_Loader {
        /**
         * INPUT_TYPES: config_name, ckpt_name
         */
        inputs?: {
            config_name: string;
            ckpt_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, VAE, STRING
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Checkpoint_Loader__Simple_ {
        /**
         * INPUT_TYPES: ckpt_name
         */
        inputs?: {
            ckpt_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, VAE, STRING
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface CLIPTextEncode__NSP_ {
        /**
         * INPUT_TYPES: mode, noodle_key, seed, text, clip
         */
        inputs?: {
            mode: string;
            noodle_key: string;
            seed: number;
            text: string;
            clip: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING, STRING, STRING
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface CLIP_Input_Switch {
        /**
         * INPUT_TYPES: clip_a, clip_b, boolean
         */
        inputs?: {
            clip_a: unknown;
            clip_b: unknown;
            boolean: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIP_Vision_Input_Switch {
        /**
         * INPUT_TYPES: clip_vision_a, clip_vision_b, boolean
         */
        inputs?: {
            clip_vision_a: unknown;
            clip_vision_b: unknown;
            boolean: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIP_VISION
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Conditioning_Input_Switch {
        /**
         * INPUT_TYPES: conditioning_a, conditioning_b, boolean
         */
        inputs?: {
            conditioning_a: unknown;
            conditioning_b: unknown;
            boolean: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Constant_Number {
        /**
         * INPUT_TYPES: number_type, number
         */
        inputs?: {
            number_type: string;
            number: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NUMBER, FLOAT, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Create_Grid_Image {
        /**
         * INPUT_TYPES: images_path, pattern_glob, include_subfolders, border_width, number_of_columns, max_cell_size, border_red, border_green, border_blue
         */
        inputs?: {
            images_path: string;
            pattern_glob: string;
            include_subfolders: string;
            border_width: number;
            number_of_columns: number;
            max_cell_size: number;
            border_red: number;
            border_green: number;
            border_blue: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Create_Grid_Image_from_Batch {
        /**
         * INPUT_TYPES: images, border_width, number_of_columns, max_cell_size, border_red, border_green, border_blue
         */
        inputs?: {
            images: unknown;
            border_width: number;
            number_of_columns: number;
            max_cell_size: number;
            border_red: number;
            border_green: number;
            border_blue: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Create_Morph_Image {
        /**
         * INPUT_TYPES: image_a, image_b, transition_frames, still_image_delay_ms, duration_ms, loops, max_size, output_path, filename, filetype
         */
        inputs?: {
            image_a: unknown;
            image_b: unknown;
            transition_frames: number;
            still_image_delay_ms: number;
            duration_ms: number;
            loops: number;
            max_size: number;
            output_path: string;
            filename: string;
            filetype: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE, STRING, STRING
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Create_Morph_Image_from_Path {
        /**
         * INPUT_TYPES: transition_frames, still_image_delay_ms, duration_ms, loops, max_size, input_path, input_pattern, output_path, filename, filetype
         */
        inputs?: {
            transition_frames: number;
            still_image_delay_ms: number;
            duration_ms: number;
            loops: number;
            max_size: number;
            input_path: string;
            input_pattern: string;
            output_path: string;
            filename: string;
            filetype: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Create_Video_from_Path {
        /**
         * INPUT_TYPES: transition_frames, image_delay_sec, fps, max_size, input_path, output_path, filename, codec
         */
        inputs?: {
            transition_frames: number;
            image_delay_sec: number;
            fps: number;
            max_size: number;
            input_path: string;
            output_path: string;
            filename: string;
            codec: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface CLIPSeg_Masking {
        /**
         * INPUT_TYPES: image, text
         */
        inputs?: {
            image: unknown;
            text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface CLIPSeg_Model_Loader {
        /**
         * INPUT_TYPES: model
         */
        inputs?: {
            model: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CLIPSEG_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface CLIPSeg_Batch_Masking {
        /**
         * INPUT_TYPES: image_a, image_b, text_a, text_b
         */
        inputs?: {
            image_a: unknown;
            image_b: unknown;
            text_a: string;
            text_b: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, IMAGE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Convert_Masks_to_Images {
        /**
         * INPUT_TYPES: masks
         */
        inputs?: {
            masks: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Control_Net_Model_Input_Switch {
        /**
         * INPUT_TYPES: control_net_a, control_net_b, boolean
         */
        inputs?: {
            control_net_a: unknown;
            control_net_b: unknown;
            boolean: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONTROL_NET
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Debug_Number_to_Console {
        /**
         * INPUT_TYPES: number, label
         */
        inputs?: {
            number: unknown;
            label: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NUMBER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Dictionary_to_Console {
        /**
         * INPUT_TYPES: dictionary, label
         */
        inputs?: {
            dictionary: unknown;
            label: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: DICT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Diffusers_Model_Loader {
        /**
         * INPUT_TYPES: model_path
         */
        inputs?: {
            model_path: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, VAE, STRING
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Diffusers_Hub_Model_Down_Loader {
        /**
         * INPUT_TYPES: repo_id, revision
         */
        inputs?: {
            repo_id: string;
            revision: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, VAE, STRING
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Export_API {
        /**
         * INPUT_TYPES: save_prompt_api, output_path, filename_prefix, filename_delimiter, filename_number_padding, parse_text_tokens
         */
        inputs?: {
            save_prompt_api: string;
            output_path: string;
            filename_prefix: string;
            filename_delimiter: string;
            filename_number_padding: number;
            parse_text_tokens: unknown;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface Latent_Input_Switch {
        /**
         * INPUT_TYPES: latent_a, latent_b, boolean
         */
        inputs?: {
            latent_a: unknown;
            latent_b: unknown;
            boolean: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Load_Cache {
        /**
         * INPUT_TYPES: latent_path, image_path, conditioning_path
         */
        inputs?: {
            latent_path: string;
            image_path: string;
            conditioning_path: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT, IMAGE, CONDITIONING
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Logic_Boolean {
        /**
         * INPUT_TYPES: boolean
         */
        inputs?: {
            boolean: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN, NUMBER, INT, FLOAT
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Logic_Boolean_Primitive {
        /**
         * INPUT_TYPES: boolean
         */
        inputs?: {
            boolean: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Logic_Comparison_OR {
        /**
         * INPUT_TYPES: boolean_a, boolean_b
         */
        inputs?: {
            boolean_a: unknown;
            boolean_b: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Logic_Comparison_AND {
        /**
         * INPUT_TYPES: boolean_a, boolean_b
         */
        inputs?: {
            boolean_a: unknown;
            boolean_b: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Logic_Comparison_XOR {
        /**
         * INPUT_TYPES: boolean_a, boolean_b
         */
        inputs?: {
            boolean_a: unknown;
            boolean_b: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Logic_NOT {
        /**
         * INPUT_TYPES: boolean
         */
        inputs?: {
            boolean: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Lora_Loader {
        /**
         * INPUT_TYPES: model, clip, lora_name, strength_model, strength_clip
         */
        inputs?: {
            model: unknown;
            clip: unknown;
            lora_name: string;
            strength_model: number;
            strength_clip: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, STRING
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Hex_to_HSL {
        /**
         * INPUT_TYPES: hex_color
         */
        inputs?: {
            hex_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, INT, INT, FLOAT, STRING
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface HSL_to_Hex {
        /**
         * INPUT_TYPES: hsl_color
         */
        inputs?: {
            hsl_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_SSAO__Ambient_Occlusion_ {
        /**
         * INPUT_TYPES: images, depth_images, strength, radius, ao_blur, specular_threshold, enable_specular_masking, tile_size
         */
        inputs?: {
            images: unknown;
            depth_images: unknown;
            strength: number;
            radius: number;
            ao_blur: number;
            specular_threshold: number;
            enable_specular_masking: string;
            tile_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE, IMAGE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_SSDO__Direct_Occlusion_ {
        /**
         * INPUT_TYPES: images, depth_images, strength, radius, specular_threshold, colored_occlusion
         */
        inputs?: {
            images: unknown;
            depth_images: unknown;
            strength: number;
            radius: number;
            specular_threshold: number;
            colored_occlusion: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE, IMAGE, IMAGE
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Analyze {
        /**
         * INPUT_TYPES: image, mode
         */
        inputs?: {
            image: unknown;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Aspect_Ratio {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NUMBER, FLOAT, NUMBER, STRING, STRING
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Batch {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Blank {
        /**
         * INPUT_TYPES: width, height, red, green, blue
         */
        inputs?: {
            width: number;
            height: number;
            red: number;
            green: number;
            blue: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Blend_by_Mask {
        /**
         * INPUT_TYPES: image_a, image_b, mask, blend_percentage
         */
        inputs?: {
            image_a: unknown;
            image_b: unknown;
            mask: unknown;
            blend_percentage: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Blend {
        /**
         * INPUT_TYPES: image_a, image_b, blend_percentage
         */
        inputs?: {
            image_a: unknown;
            image_b: unknown;
            blend_percentage: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Blending_Mode {
        /**
         * INPUT_TYPES: image_a, image_b, mode, blend_percentage
         */
        inputs?: {
            image_a: unknown;
            image_b: unknown;
            mode: string;
            blend_percentage: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Bloom_Filter {
        /**
         * INPUT_TYPES: image, radius, intensity
         */
        inputs?: {
            image: unknown;
            radius: number;
            intensity: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Canny_Filter {
        /**
         * INPUT_TYPES: images, enable_threshold, threshold_low, threshold_high
         */
        inputs?: {
            images: unknown;
            enable_threshold: string;
            threshold_low: number;
            threshold_high: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Chromatic_Aberration {
        /**
         * INPUT_TYPES: image, red_offset, green_offset, blue_offset, intensity, fade_radius
         */
        inputs?: {
            image: unknown;
            red_offset: number;
            green_offset: number;
            blue_offset: number;
            intensity: number;
            fade_radius: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Color_Palette {
        /**
         * INPUT_TYPES: image, colors, mode
         */
        inputs?: {
            image: unknown;
            colors: number;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, LIST
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Crop_Face {
        /**
         * INPUT_TYPES: image, crop_padding_factor, cascade_xml
         */
        inputs?: {
            image: unknown;
            crop_padding_factor: number;
            cascade_xml: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, CROP_DATA
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Crop_Location {
        /**
         * INPUT_TYPES: image, top, left, right, bottom
         */
        inputs?: {
            image: unknown;
            top: number;
            left: number;
            right: number;
            bottom: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, CROP_DATA
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Crop_Square_Location {
        /**
         * INPUT_TYPES: image, x, y, size
         */
        inputs?: {
            image: unknown;
            x: number;
            y: number;
            size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, CROP_DATA
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Displacement_Warp {
        /**
         * INPUT_TYPES: images, displacement_maps, amplitude
         */
        inputs?: {
            images: unknown;
            displacement_maps: unknown;
            amplitude: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Lucy_Sharpen {
        /**
         * INPUT_TYPES: images, iterations, kernel_size
         */
        inputs?: {
            images: unknown;
            iterations: number;
            kernel_size: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Paste_Face {
        /**
         * INPUT_TYPES: image, crop_image, crop_data, crop_blending, crop_sharpening
         */
        inputs?: {
            image: unknown;
            crop_image: unknown;
            crop_data: unknown;
            crop_blending: number;
            crop_sharpening: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Paste_Crop {
        /**
         * INPUT_TYPES: image, crop_image, crop_data, crop_blending, crop_sharpening
         */
        inputs?: {
            image: unknown;
            crop_image: unknown;
            crop_data: unknown;
            crop_blending: number;
            crop_sharpening: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Paste_Crop_by_Location {
        /**
         * INPUT_TYPES: image, crop_image, top, left, right, bottom, crop_blending, crop_sharpening
         */
        inputs?: {
            image: unknown;
            crop_image: unknown;
            top: number;
            left: number;
            right: number;
            bottom: number;
            crop_blending: number;
            crop_sharpening: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Pixelate {
        /**
         * INPUT_TYPES: images, pixelation_size, num_colors, init_mode, max_iterations, dither, dither_mode
         */
        inputs?: {
            images: unknown;
            pixelation_size: number;
            num_colors: number;
            init_mode: string;
            max_iterations: number;
            dither: string;
            dither_mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Power_Noise {
        /**
         * INPUT_TYPES: width, height, frequency, attenuation, noise_type, seed
         */
        inputs?: {
            width: number;
            height: number;
            frequency: number;
            attenuation: number;
            noise_type: string;
            seed: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Dragan_Photography_Filter {
        /**
         * INPUT_TYPES: image, saturation, contrast, brightness, sharpness, highpass_radius, highpass_samples, highpass_strength, colorize
         */
        inputs?: {
            image: unknown;
            saturation: number;
            contrast: number;
            brightness: number;
            sharpness: number;
            highpass_radius: number;
            highpass_samples: number;
            highpass_strength: number;
            colorize: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Edge_Detection_Filter {
        /**
         * INPUT_TYPES: image, mode
         */
        inputs?: {
            image: unknown;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Film_Grain {
        /**
         * INPUT_TYPES: image, density, intensity, highlights, supersample_factor
         */
        inputs?: {
            image: unknown;
            density: number;
            intensity: number;
            highlights: number;
            supersample_factor: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Filter_Adjustments {
        /**
         * INPUT_TYPES: image, brightness, contrast, saturation, sharpness, blur, gaussian_blur, edge_enhance, detail_enhance
         */
        inputs?: {
            image: unknown;
            brightness: number;
            contrast: number;
            saturation: number;
            sharpness: number;
            blur: number;
            gaussian_blur: number;
            edge_enhance: number;
            detail_enhance: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Flip {
        /**
         * INPUT_TYPES: images, mode
         */
        inputs?: {
            images: unknown;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Gradient_Map {
        /**
         * INPUT_TYPES: image, gradient_image, flip_left_right
         */
        inputs?: {
            image: unknown;
            gradient_image: unknown;
            flip_left_right: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Generate_Gradient {
        /**
         * INPUT_TYPES: width, height, direction, tolerance, gradient_stops
         */
        inputs?: {
            width: number;
            height: number;
            direction: string;
            tolerance: number;
            gradient_stops: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_High_Pass_Filter {
        /**
         * INPUT_TYPES: images, radius, strength, color_output, neutral_background
         */
        inputs?: {
            images: unknown;
            radius: number;
            strength: number;
            color_output: string;
            neutral_background: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_History_Loader {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Input_Switch {
        /**
         * INPUT_TYPES: image_a, image_b, boolean
         */
        inputs?: {
            image_a: unknown;
            image_b: unknown;
            boolean: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Levels_Adjustment {
        /**
         * INPUT_TYPES: image, black_level, mid_level, white_level
         */
        inputs?: {
            image: unknown;
            black_level: number;
            mid_level: number;
            white_level: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Load {
        /**
         * INPUT_TYPES: image_path, RGBA
         */
        inputs?: {
            image_path: string;
            RGBA: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK, STRING
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Median_Filter {
        /**
         * INPUT_TYPES: image, diameter, sigma_color, sigma_space
         */
        inputs?: {
            image: unknown;
            diameter: number;
            sigma_color: number;
            sigma_space: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Mix_RGB_Channels {
        /**
         * INPUT_TYPES: red_channel, green_channel, blue_channel
         */
        inputs?: {
            red_channel: unknown;
            green_channel: unknown;
            blue_channel: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Monitor_Effects_Filter {
        /**
         * INPUT_TYPES: image, mode, amplitude, offset
         */
        inputs?: {
            image: unknown;
            mode: string;
            amplitude: number;
            offset: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Nova_Filter {
        /**
         * INPUT_TYPES: image, amplitude, frequency
         */
        inputs?: {
            image: unknown;
            amplitude: number;
            frequency: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Padding {
        /**
         * INPUT_TYPES: image, feathering, feather_second_pass, left_padding, right_padding, top_padding, bottom_padding
         */
        inputs?: {
            image: unknown;
            feathering: number;
            feather_second_pass: string;
            left_padding: number;
            right_padding: number;
            top_padding: number;
            bottom_padding: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Perlin_Noise {
        /**
         * INPUT_TYPES: width, height, scale, octaves, persistence, seed
         */
        inputs?: {
            width: number;
            height: number;
            scale: number;
            octaves: number;
            persistence: number;
            seed: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Rembg__Remove_Background_ {
        /**
         * INPUT_TYPES: images, transparency, model, post_processing, only_mask, alpha_matting, alpha_matting_foreground_threshold, alpha_matting_background_threshold, alpha_matting_erode_size, background_color
         */
        inputs?: {
            images: unknown;
            transparency: unknown;
            model: string;
            post_processing: unknown;
            only_mask: unknown;
            alpha_matting: unknown;
            alpha_matting_foreground_threshold: number;
            alpha_matting_background_threshold: number;
            alpha_matting_erode_size: number;
            background_color: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Perlin_Power_Fractal {
        /**
         * INPUT_TYPES: width, height, scale, octaves, persistence, lacunarity, exponent, seed
         */
        inputs?: {
            width: number;
            height: number;
            scale: number;
            octaves: number;
            persistence: number;
            lacunarity: number;
            exponent: number;
            seed: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Remove_Background__Alpha_ {
        /**
         * INPUT_TYPES: images, mode, threshold, threshold_tolerance
         */
        inputs?: {
            images: unknown;
            mode: string;
            threshold: number;
            threshold_tolerance: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Remove_Color {
        /**
         * INPUT_TYPES: image, target_red, target_green, target_blue, replace_red, replace_green, replace_blue, clip_threshold
         */
        inputs?: {
            image: unknown;
            target_red: number;
            target_green: number;
            target_blue: number;
            replace_red: number;
            replace_green: number;
            replace_blue: number;
            clip_threshold: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Resize {
        /**
         * INPUT_TYPES: image, mode, supersample, resampling, rescale_factor, resize_width, resize_height
         */
        inputs?: {
            image: unknown;
            mode: string;
            supersample: string;
            resampling: string;
            rescale_factor: number;
            resize_width: number;
            resize_height: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Rotate {
        /**
         * INPUT_TYPES: images, mode, rotation, sampler
         */
        inputs?: {
            images: unknown;
            mode: string;
            rotation: number;
            sampler: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Rotate_Hue {
        /**
         * INPUT_TYPES: image, hue_shift
         */
        inputs?: {
            image: unknown;
            hue_shift: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Send_HTTP {
        /**
         * INPUT_TYPES: images, url, method_type, request_field_name
         */
        inputs?: {
            images: unknown;
            url: string;
            method_type: string;
            request_field_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Save {
        /**
         * INPUT_TYPES: images, output_path, filename_prefix, filename_delimiter, filename_number_padding, filename_number_start, extension, dpi, quality, optimize_image, lossless_webp, overwrite_mode, show_history, show_history_by_prefix, embed_workflow, show_previews
         */
        inputs?: {
            images: unknown;
            output_path: string;
            filename_prefix: string;
            filename_delimiter: string;
            filename_number_padding: number;
            filename_number_start: string;
            extension: string;
            dpi: number;
            quality: number;
            optimize_image: string;
            lossless_webp: string;
            overwrite_mode: string;
            show_history: string;
            show_history_by_prefix: string;
            embed_workflow: string;
            show_previews: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Seamless_Texture {
        /**
         * INPUT_TYPES: images, blending, tiled, tiles
         */
        inputs?: {
            images: unknown;
            blending: number;
            tiled: string;
            tiles: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Select_Channel {
        /**
         * INPUT_TYPES: image, channel
         */
        inputs?: {
            image: unknown;
            channel: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Select_Color {
        /**
         * INPUT_TYPES: image, red, green, blue, variance
         */
        inputs?: {
            image: unknown;
            red: number;
            green: number;
            blue: number;
            variance: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Shadows_and_Highlights {
        /**
         * INPUT_TYPES: image, shadow_threshold, shadow_factor, shadow_smoothing, highlight_threshold, highlight_factor, highlight_smoothing, simplify_isolation
         */
        inputs?: {
            image: unknown;
            shadow_threshold: number;
            shadow_factor: number;
            shadow_smoothing: number;
            highlight_threshold: number;
            highlight_factor: number;
            highlight_smoothing: number;
            simplify_isolation: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE, IMAGE
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Size_to_Number {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NUMBER, NUMBER, FLOAT, FLOAT, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Stitch {
        /**
         * INPUT_TYPES: image_a, image_b, stitch, feathering
         */
        inputs?: {
            image_a: unknown;
            image_b: unknown;
            stitch: string;
            feathering: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Style_Filter {
        /**
         * INPUT_TYPES: image, style
         */
        inputs?: {
            image: unknown;
            style: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Threshold {
        /**
         * INPUT_TYPES: image, threshold
         */
        inputs?: {
            image: unknown;
            threshold: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Tiled {
        /**
         * INPUT_TYPES: image, num_tiles
         */
        inputs?: {
            image: unknown;
            num_tiles: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Transpose {
        /**
         * INPUT_TYPES: image, image_overlay, width, height, X, Y, rotation, feathering
         */
        inputs?: {
            image: unknown;
            image_overlay: unknown;
            width: number;
            height: number;
            X: number;
            Y: number;
            rotation: number;
            feathering: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_fDOF_Filter {
        /**
         * INPUT_TYPES: image, depth, mode, radius, samples
         */
        inputs?: {
            image: unknown;
            depth: unknown;
            mode: string;
            radius: number;
            samples: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_to_Latent_Mask {
        /**
         * INPUT_TYPES: images, channel
         */
        inputs?: {
            images: unknown;
            channel: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_to_Noise {
        /**
         * INPUT_TYPES: images, num_colors, black_mix, gaussian_mix, brightness, output_mode, seed
         */
        inputs?: {
            images: unknown;
            num_colors: number;
            black_mix: number;
            gaussian_mix: number;
            brightness: number;
            output_mode: string;
            seed: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_to_Seed {
        /**
         * INPUT_TYPES: images
         */
        inputs?: {
            images: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Images_to_RGB {
        /**
         * INPUT_TYPES: images
         */
        inputs?: {
            images: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Images_to_Linear {
        /**
         * INPUT_TYPES: images
         */
        inputs?: {
            images: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Integer_place_counter {
        /**
         * INPUT_TYPES: int_input
         */
        inputs?: {
            int_input: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Voronoi_Noise_Filter {
        /**
         * INPUT_TYPES: width, height, density, modulator, seed
         */
        inputs?: {
            width: number;
            height: number;
            density: number;
            modulator: number;
            seed: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface KSampler__WAS_ {
        /**
         * INPUT_TYPES: model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise
         */
        inputs?: {
            model: unknown;
            seed: unknown;
            steps: number;
            cfg: number;
            sampler_name: string;
            scheduler: string;
            positive: unknown;
            negative: unknown;
            latent_image: unknown;
            denoise: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface KSampler_Cycle {
        /**
         * INPUT_TYPES: model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, tiled_vae, latent_upscale, upscale_factor, upscale_cycles, starting_denoise, cycle_denoise, scale_denoise, scale_sampling, vae
         */
        inputs?: {
            model: unknown;
            seed: number;
            steps: number;
            cfg: number;
            sampler_name: string;
            scheduler: string;
            positive: unknown;
            negative: unknown;
            latent_image: unknown;
            tiled_vae: string;
            latent_upscale: string;
            upscale_factor: number;
            upscale_cycles: number;
            starting_denoise: number;
            cycle_denoise: number;
            scale_denoise: string;
            scale_sampling: string;
            vae: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Latent_Batch {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Latent_Noise_Injection {
        /**
         * INPUT_TYPES: samples, noise_std
         */
        inputs?: {
            samples: unknown;
            noise_std: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Latent_Size_to_Number {
        /**
         * INPUT_TYPES: samples
         */
        inputs?: {
            samples: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NUMBER, NUMBER, FLOAT, FLOAT, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Latent_Upscale_by_Factor__WAS_ {
        /**
         * INPUT_TYPES: samples, mode, factor, align
         */
        inputs?: {
            samples: unknown;
            mode: string;
            factor: number;
            align: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Load_Image_Batch {
        /**
         * INPUT_TYPES: mode, seed, index, label, path, pattern, allow_RGBA_output
         */
        inputs?: {
            mode: string;
            seed: number;
            index: number;
            label: string;
            path: string;
            pattern: string;
            allow_RGBA_output: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Load_Text_File {
        /**
         * INPUT_TYPES: file_path, dictionary_name
         */
        inputs?: {
            file_path: string;
            dictionary_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, DICT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Load_Lora {
        /**
         * INPUT_TYPES: model, clip, lora_name, strength_model, strength_clip
         */
        inputs?: {
            model: unknown;
            clip: unknown;
            lora_name: string;
            strength_model: number;
            strength_clip: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, STRING
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Lora_Input_Switch {
        /**
         * INPUT_TYPES: model_a, clip_a, model_b, clip_b, boolean
         */
        inputs?: {
            model_a: unknown;
            clip_a: unknown;
            model_b: unknown;
            clip_b: unknown;
            boolean: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Masks_Add {
        /**
         * INPUT_TYPES: masks_a, masks_b
         */
        inputs?: {
            masks_a: unknown;
            masks_b: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Masks_Subtract {
        /**
         * INPUT_TYPES: masks_a, masks_b
         */
        inputs?: {
            masks_a: unknown;
            masks_b: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Arbitrary_Region {
        /**
         * INPUT_TYPES: masks, size, threshold
         */
        inputs?: {
            masks: unknown;
            size: number;
            threshold: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Batch_to_Mask {
        /**
         * INPUT_TYPES: masks, batch_number
         */
        inputs?: {
            masks: unknown;
            batch_number: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Batch {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Ceiling_Region {
        /**
         * INPUT_TYPES: masks
         */
        inputs?: {
            masks: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Crop_Dominant_Region {
        /**
         * INPUT_TYPES: masks, padding
         */
        inputs?: {
            masks: unknown;
            padding: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Crop_Minority_Region {
        /**
         * INPUT_TYPES: masks, padding
         */
        inputs?: {
            masks: unknown;
            padding: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Crop_Region {
        /**
         * INPUT_TYPES: mask, padding, region_type
         */
        inputs?: {
            mask: unknown;
            padding: number;
            region_type: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK, CROP_DATA, INT, INT, INT, INT, INT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Mask_Paste_Region {
        /**
         * INPUT_TYPES: mask, crop_mask, crop_data, crop_blending, crop_sharpening
         */
        inputs?: {
            mask: unknown;
            crop_mask: unknown;
            crop_data: unknown;
            crop_blending: number;
            crop_sharpening: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Mask_Dilate_Region {
        /**
         * INPUT_TYPES: masks, iterations
         */
        inputs?: {
            masks: unknown;
            iterations: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Dominant_Region {
        /**
         * INPUT_TYPES: masks, threshold
         */
        inputs?: {
            masks: unknown;
            threshold: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Erode_Region {
        /**
         * INPUT_TYPES: masks, iterations
         */
        inputs?: {
            masks: unknown;
            iterations: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Fill_Holes {
        /**
         * INPUT_TYPES: masks
         */
        inputs?: {
            masks: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Floor_Region {
        /**
         * INPUT_TYPES: masks
         */
        inputs?: {
            masks: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Gaussian_Region {
        /**
         * INPUT_TYPES: masks, radius
         */
        inputs?: {
            masks: unknown;
            radius: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Invert {
        /**
         * INPUT_TYPES: masks
         */
        inputs?: {
            masks: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Minority_Region {
        /**
         * INPUT_TYPES: masks, threshold
         */
        inputs?: {
            masks: unknown;
            threshold: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Rect_Area {
        /**
         * INPUT_TYPES: x, y, width, height, blur_radius
         */
        inputs?: {
            x: number;
            y: number;
            width: number;
            height: number;
            blur_radius: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Rect_Area__Advanced_ {
        /**
         * INPUT_TYPES: x, y, width, height, image_width, image_height, blur_radius
         */
        inputs?: {
            x: number;
            y: number;
            width: number;
            height: number;
            image_width: number;
            image_height: number;
            blur_radius: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Smooth_Region {
        /**
         * INPUT_TYPES: masks, sigma
         */
        inputs?: {
            masks: unknown;
            sigma: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Mask_Threshold_Region {
        /**
         * INPUT_TYPES: masks, black_threshold, white_threshold
         */
        inputs?: {
            masks: unknown;
            black_threshold: number;
            white_threshold: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Masks_Combine_Regions {
        /**
         * INPUT_TYPES: mask_a, mask_b
         */
        inputs?: {
            mask_a: unknown;
            mask_b: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Masks_Combine_Batch {
        /**
         * INPUT_TYPES: masks
         */
        inputs?: {
            masks: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MASK
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MiDaS_Model_Loader {
        /**
         * INPUT_TYPES: midas_model
         */
        inputs?: {
            midas_model: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MIDAS_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MiDaS_Depth_Approximation {
        /**
         * INPUT_TYPES: image, use_cpu, midas_type, invert_depth
         */
        inputs?: {
            image: unknown;
            use_cpu: string;
            midas_type: string;
            invert_depth: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface MiDaS_Mask_Image {
        /**
         * INPUT_TYPES: image, use_cpu, midas_model, remove, threshold, threshold_low, threshold_mid, threshold_high, smoothing, background_red, background_green, background_blue
         */
        inputs?: {
            image: unknown;
            use_cpu: string;
            midas_model: string;
            remove: string;
            threshold: string;
            threshold_low: number;
            threshold_mid: number;
            threshold_high: number;
            smoothing: number;
            background_red: number;
            background_green: number;
            background_blue: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Model_Input_Switch {
        /**
         * INPUT_TYPES: model_a, model_b, boolean
         */
        inputs?: {
            model_a: unknown;
            model_b: unknown;
            boolean: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Number_Counter {
        /**
         * INPUT_TYPES: number_type, mode, start, stop, step
         */
        inputs?: {
            number_type: string;
            mode: string;
            start: number;
            stop: number;
            step: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NUMBER, FLOAT, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Number_Operation {
        /**
         * INPUT_TYPES: number_a, number_b, operation
         */
        inputs?: {
            number_a: unknown;
            number_b: unknown;
            operation: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NUMBER, FLOAT, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Number_to_Float {
        /**
         * INPUT_TYPES: number
         */
        inputs?: {
            number: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: FLOAT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Number_Input_Switch {
        /**
         * INPUT_TYPES: number_a, number_b, boolean
         */
        inputs?: {
            number_a: unknown;
            number_b: unknown;
            boolean: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NUMBER, FLOAT, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Number_Input_Condition {
        /**
         * INPUT_TYPES: number_a, number_b, return_boolean, comparison
         */
        inputs?: {
            number_a: unknown;
            number_b: unknown;
            return_boolean: string;
            comparison: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NUMBER, FLOAT, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Number_Multiple_Of {
        /**
         * INPUT_TYPES: number, multiple
         */
        inputs?: {
            number: unknown;
            multiple: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NUMBER, FLOAT, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Number_PI {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NUMBER, FLOAT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Number_to_Int {
        /**
         * INPUT_TYPES: number
         */
        inputs?: {
            number: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: INT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Number_to_Seed {
        /**
         * INPUT_TYPES: number
         */
        inputs?: {
            number: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SEED
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Number_to_String {
        /**
         * INPUT_TYPES: number
         */
        inputs?: {
            number: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Number_to_Text {
        /**
         * INPUT_TYPES: number
         */
        inputs?: {
            number: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Boolean_To_Text {
        /**
         * INPUT_TYPES: boolean
         */
        inputs?: {
            boolean: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Prompt_Styles_Selector {
        /**
         * INPUT_TYPES: style
         */
        inputs?: {
            style: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Prompt_Multiple_Styles_Selector {
        /**
         * INPUT_TYPES: style1, style2, style3, style4
         */
        inputs?: {
            style1: string;
            style2: string;
            style3: string;
            style4: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Random_Number {
        /**
         * INPUT_TYPES: number_type, minimum, maximum, seed
         */
        inputs?: {
            number_type: string;
            minimum: number;
            maximum: number;
            seed: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NUMBER, FLOAT, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Save_Text_File {
        /**
         * INPUT_TYPES: text, path, filename_prefix, filename_delimiter, filename_number_padding
         */
        inputs?: {
            text: string;
            path: string;
            filename_prefix: string;
            filename_delimiter: string;
            filename_number_padding: number;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface Seed {
        /**
         * INPUT_TYPES: seed
         */
        inputs?: {
            seed: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SEED, NUMBER, FLOAT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Tensor_Batch_to_Image {
        /**
         * INPUT_TYPES: images_batch, batch_image_number
         */
        inputs?: {
            images_batch: unknown;
            batch_image_number: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface BLIP_Analyze_Image {
        /**
         * INPUT_TYPES: images, mode, question, blip_model
         */
        inputs?: {
            images: unknown;
            mode: string;
            question: string;
            blip_model: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface SAM_Model_Loader {
        /**
         * INPUT_TYPES: model_size
         */
        inputs?: {
            model_size: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAM_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SAM_Parameters {
        /**
         * INPUT_TYPES: points, labels
         */
        inputs?: {
            points: string;
            labels: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAM_PARAMETERS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SAM_Parameters_Combine {
        /**
         * INPUT_TYPES: sam_parameters_a, sam_parameters_b
         */
        inputs?: {
            sam_parameters_a: unknown;
            sam_parameters_b: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: SAM_PARAMETERS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SAM_Image_Mask {
        /**
         * INPUT_TYPES: sam_model, sam_parameters, image
         */
        inputs?: {
            sam_model: unknown;
            sam_parameters: unknown;
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, MASK
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Samples_Passthrough__Stat_System_ {
        /**
         * INPUT_TYPES: samples
         */
        inputs?: {
            samples: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LATENT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface String_to_Text {
        /**
         * INPUT_TYPES: string
         */
        inputs?: {
            string: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Image_Bounds {
        /**
         * INPUT_TYPES: image
         */
        inputs?: {
            image: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE_BOUNDS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Inset_Image_Bounds {
        /**
         * INPUT_TYPES: image_bounds, inset_left, inset_right, inset_top, inset_bottom
         */
        inputs?: {
            image_bounds: unknown;
            inset_left: number;
            inset_right: number;
            inset_top: number;
            inset_bottom: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE_BOUNDS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Bounded_Image_Blend {
        /**
         * INPUT_TYPES: target, target_bounds, source, blend_factor, feathering
         */
        inputs?: {
            target: unknown;
            target_bounds: unknown;
            source: unknown;
            blend_factor: number;
            feathering: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Bounded_Image_Blend_with_Mask {
        /**
         * INPUT_TYPES: target, target_mask, target_bounds, source, blend_factor, feathering
         */
        inputs?: {
            target: unknown;
            target_mask: unknown;
            target_bounds: unknown;
            source: unknown;
            blend_factor: number;
            feathering: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Bounded_Image_Crop {
        /**
         * INPUT_TYPES: image, image_bounds
         */
        inputs?: {
            image: unknown;
            image_bounds: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Bounded_Image_Crop_with_Mask {
        /**
         * INPUT_TYPES: image, mask, padding_left, padding_right, padding_top, padding_bottom
         */
        inputs?: {
            image: unknown;
            mask: unknown;
            padding_left: number;
            padding_right: number;
            padding_top: number;
            padding_bottom: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, IMAGE_BOUNDS
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Image_Bounds_to_Console {
        /**
         * INPUT_TYPES: image_bounds, label
         */
        inputs?: {
            image_bounds: unknown;
            label: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE_BOUNDS
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Dictionary_Update {
        /**
         * INPUT_TYPES: dictionary_a, dictionary_b
         */
        inputs?: {
            dictionary_a: unknown;
            dictionary_b: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: DICT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Dictionary_Get {
        /**
         * INPUT_TYPES: dictionary, key
         */
        inputs?: {
            dictionary: unknown;
            key: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Dictionary_Convert {
        /**
         * INPUT_TYPES: dictionary_text
         */
        inputs?: {
            dictionary_text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: DICT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Dictionary_New {
        /**
         * INPUT_TYPES: key_1, value_1
         */
        inputs?: {
            key_1: string;
            value_1: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: DICT
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Dictionary_Keys {
        /**
         * INPUT_TYPES: dictionary
         */
        inputs?: {
            dictionary: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LIST
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Dictionary_To_Text {
        /**
         * INPUT_TYPES: dictionary
         */
        inputs?: {
            dictionary: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Add_Tokens {
        /**
         * INPUT_TYPES: tokens, print_current_tokens
         */
        inputs?: {
            tokens: string;
            print_current_tokens: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface Text_Add_Token_by_Input {
        /**
         * INPUT_TYPES: token_name, token_value, print_current_tokens
         */
        inputs?: {
            token_name: string;
            token_value: string;
            print_current_tokens: string;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
    interface Text_Compare {
        /**
         * INPUT_TYPES: text_a, text_b, mode, tolerance
         */
        inputs?: {
            text_a: string;
            text_b: string;
            mode: string;
            tolerance: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, STRING, BOOLEAN, NUMBER, STRING
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Text_Concatenate {
        /**
         * INPUT_TYPES: delimiter, clean_whitespace
         */
        inputs?: {
            delimiter: string;
            clean_whitespace: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_File_History_Loader {
        /**
         * INPUT_TYPES: file, dictionary_name
         */
        inputs?: {
            file: string;
            dictionary_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, DICT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Text_Find_and_Replace_by_Dictionary {
        /**
         * INPUT_TYPES: text, dictionary, replacement_key, seed
         */
        inputs?: {
            text: string;
            dictionary: unknown;
            replacement_key: string;
            seed: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Find_and_Replace_Input {
        /**
         * INPUT_TYPES: text, find, replace
         */
        inputs?: {
            text: string;
            find: string;
            replace: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, NUMBER, FLOAT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Text_Find_and_Replace {
        /**
         * INPUT_TYPES: text, find, replace
         */
        inputs?: {
            text: string;
            find: string;
            replace: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, NUMBER, FLOAT, INT
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Text_Find {
        /**
         * INPUT_TYPES: text, substring, pattern
         */
        inputs?: {
            text: string;
            substring: string;
            pattern: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Input_Switch {
        /**
         * INPUT_TYPES: text_a, text_b, boolean
         */
        inputs?: {
            text_a: string;
            text_b: string;
            boolean: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_List {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LIST
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_List_Concatenate {
        /**
         * INPUT_TYPES:
         */
        inputs?: {
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: LIST
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_List_to_Text {
        /**
         * INPUT_TYPES: delimiter, text_list
         */
        inputs?: {
            delimiter: string;
            text_list: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Load_Line_From_File {
        /**
         * INPUT_TYPES: file_path, dictionary_name, label, mode, index
         */
        inputs?: {
            file_path: string;
            dictionary_name: string;
            label: string;
            mode: string;
            index: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, DICT
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Text_Multiline {
        /**
         * INPUT_TYPES: text
         */
        inputs?: {
            text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Multiline__Code_Compatible_ {
        /**
         * INPUT_TYPES: text
         */
        inputs?: {
            text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Parse_A1111_Embeddings {
        /**
         * INPUT_TYPES: text
         */
        inputs?: {
            text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Parse_Noodle_Soup_Prompts {
        /**
         * INPUT_TYPES: mode, noodle_key, seed, text
         */
        inputs?: {
            mode: string;
            noodle_key: string;
            seed: number;
            text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Parse_Tokens {
        /**
         * INPUT_TYPES: text
         */
        inputs?: {
            text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Random_Line {
        /**
         * INPUT_TYPES: text, seed
         */
        inputs?: {
            text: string;
            seed: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Random_Prompt {
        /**
         * INPUT_TYPES: search_seed
         */
        inputs?: {
            search_seed: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_String {
        /**
         * INPUT_TYPES: text
         */
        inputs?: {
            text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, STRING, STRING, STRING
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Text_Contains {
        /**
         * INPUT_TYPES: text, sub_text
         */
        inputs?: {
            text: string;
            sub_text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: BOOLEAN
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Shuffle {
        /**
         * INPUT_TYPES: text, separator, seed
         */
        inputs?: {
            text: string;
            separator: string;
            seed: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_Sort {
        /**
         * INPUT_TYPES: text, separator
         */
        inputs?: {
            text: string;
            separator: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_to_Conditioning {
        /**
         * INPUT_TYPES: clip, text
         */
        inputs?: {
            clip: unknown;
            text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: CONDITIONING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_to_Console {
        /**
         * INPUT_TYPES: text, label
         */
        inputs?: {
            text: string;
            label: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_to_Number {
        /**
         * INPUT_TYPES: text
         */
        inputs?: {
            text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NUMBER
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_to_String {
        /**
         * INPUT_TYPES: text
         */
        inputs?: {
            text: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Text_String_Truncate {
        /**
         * INPUT_TYPES: text, truncate_by, truncate_from, truncate_to
         */
        inputs?: {
            text: string;
            truncate_by: string;
            truncate_from: string;
            truncate_to: number;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, STRING, STRING, STRING
         */
        outputs?: [unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface True_Random_org_Number_Generator {
        /**
         * INPUT_TYPES: api_key, minimum, maximum, mode
         */
        inputs?: {
            api_key: string;
            minimum: number;
            maximum: number;
            mode: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: NUMBER, FLOAT, INT
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface unCLIP_Checkpoint_Loader {
        /**
         * INPUT_TYPES: ckpt_name
         */
        inputs?: {
            ckpt_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: MODEL, CLIP, VAE, CLIP_VISION, STRING
         */
        outputs?: [unknown, unknown, unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Upscale_Model_Loader {
        /**
         * INPUT_TYPES: model_name
         */
        inputs?: {
            model_name: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: UPSCALE_MODEL, STRING
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface Upscale_Model_Switch {
        /**
         * INPUT_TYPES: upscale_model_a, upscale_model_b, boolean
         */
        inputs?: {
            upscale_model_a: unknown;
            upscale_model_b: unknown;
            boolean: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: UPSCALE_MODEL
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Write_to_GIF {
        /**
         * INPUT_TYPES: image, transition_frames, image_delay_ms, duration_ms, loops, max_size, output_path, filename
         */
        inputs?: {
            image: unknown;
            transition_frames: number;
            image_delay_ms: number;
            duration_ms: number;
            loops: number;
            max_size: number;
            output_path: string;
            filename: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, STRING, STRING
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface Write_to_Video {
        /**
         * INPUT_TYPES: image, transition_frames, image_delay_sec, fps, max_size, output_path, filename, codec
         */
        inputs?: {
            image: unknown;
            transition_frames: number;
            image_delay_sec: number;
            fps: number;
            max_size: number;
            output_path: string;
            filename: string;
            codec: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE, STRING, STRING
         */
        outputs?: [unknown, unknown, unknown];
        [k: string]: unknown;
    }
    interface VAE_Input_Switch {
        /**
         * INPUT_TYPES: vae_a, vae_b, boolean
         */
        inputs?: {
            vae_a: unknown;
            vae_b: unknown;
            boolean: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: VAE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface Video_Dump_Frames {
        /**
         * INPUT_TYPES: video_path, output_path, prefix, filenumber_digits, extension
         */
        inputs?: {
            video_path: string;
            output_path: string;
            prefix: string;
            filenumber_digits: number;
            extension: string;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: STRING, NUMBER
         */
        outputs?: [unknown, unknown];
        [k: string]: unknown;
    }
    interface CLIPSEG2 {
        /**
         * INPUT_TYPES: image, text, use_cuda
         */
        inputs?: {
            image: unknown;
            text: string;
            use_cuda: unknown;
            [k: string]: unknown;
        };
        /**
         * RETURN_TYPES: IMAGE
         */
        outputs?: [unknown];
        [k: string]: unknown;
    }
    interface SaveImageWebsocket {
        /**
         * INPUT_TYPES: images
         */
        inputs?: {
            images: unknown;
            [k: string]: unknown;
        };
        /** NO_OUTPUTS */
        outputs?: [];
        [k: string]: unknown;
    }
}

type NodeOutput = [string, number];
type NodeClassInputs = Record<string, string | boolean | number | null | undefined | NodeOutput>;
type InputsFormat<T> = {
    [K in keyof T]: T[K] extends {
        [k: string]: unknown;
    } ? NodeOutput : T[K] | NodeOutput;
};
interface ComfyUINodeClass<INP extends NodeClassInputs = NodeClassInputs> {
    (inputs: INP): NodeOutput[];
}
type BuiltinNodeClasses = {
    [K in keyof Required<ComfyUINodeTypes.NodeTypes>]: Required<Required<ComfyUINodeTypes.NodeTypes>[K]> extends {
        inputs: infer INP;
    } ? ComfyUINodeClass<InputsFormat<INP> & NodeClassInputs> : ComfyUINodeClass<NodeClassInputs>;
};
type InvokeOptions<T> = {
    resolver?: WorkflowOutputResolver<T>;
    progress?: (p: ComfyUiWsTypes.Messages.Progress) => void;
    polling_ms?: number;
};
/**
 * A class for creating a workflow using a fluent API.
 *
 * @example
 * ```typescript
  const workflow = new Workflow();
  const {
    KSampler,
    CheckpointLoaderSimple,
    EmptyLatentImage,
    CLIPTextEncode,
    VAEDecode,
    SaveImage,
    NODE1,
  } = workflow.classes;

  const seed = Math.floor(Math.random() * 2 ** 32);
  const pos = "best quality, 1girl";
  const neg = "worst quality, bad anatomy, embedding:NG_DeepNegative_V1_75T";
  const model1_name = "lofi_v5.baked.fp16.safetensors";
  const model2_name = "case-h-beta.baked.fp16.safetensors";
  const sampler_settings = {
    seed,
    steps: 35,
    cfg: 4,
    sampler_name: "dpmpp_2m_sde_gpu",
    scheduler: "karras",
    denoise: 1,
  };

  const [model1, clip1, vae1] = CheckpointLoaderSimple({
    ckpt_name: model1_name,
  });
  const [model2, clip2, vae2] = CheckpointLoaderSimple({
    ckpt_name: model2_name,
  });

  const dress_case = [
    "white yoga",
    "black office",
    "pink sportswear",
    "cosplay",
  ];

  const generate_pipeline = (model, clip, vae, pos, neg) => {
    const [latent_image] = EmptyLatentImage({
      width: 640,
      height: 960,
      batch_size: 1,
    });
    const [positive] = CLIPTextEncode({ text: pos, clip });
    const [negative] = CLIPTextEncode({ text: neg, clip });
    const [samples] = KSampler({
      ...sampler_settings,
      model,
      positive,
      negative,
      latent_image,
    });
    const [image] = VAEDecode({ samples, vae });
    return image;
  };

  for (const cloth of dress_case) {
    const input_pos = `${pos}, ${cloth} dress`;
    const image = generate_pipeline(model1, clip1, vae1, input_pos, neg);
    SaveImage({
      images: image,
      filename_prefix: `${cloth}-lofi-v5`,
    });

    const input_pos2 = `${pos}, ${cloth} dress`;
    const image2 = generate_pipeline(model2, clip2, vae2, input_pos2, neg);
    SaveImage({
      images: image2,
      filename_prefix: `${cloth}-case-h-beta`,
    });
  }

  return workflow;
 * ```
 */
declare class Workflow {
    protected _workflow: IWorkflow;
    protected _last_node_id: number;
    classes: BuiltinNodeClasses & Record<string, ComfyUINodeClass>;
    protected _createClassesProxy(): {};
    node<T extends keyof ComfyUINodeTypes.NodeTypes | (string & {}), C extends T extends keyof ComfyUINodeTypes.NodeTypes ? Required<Required<ComfyUINodeTypes.NodeTypes>[T]> : unknown>(node_name: T, inputs: C extends {
        inputs: infer INP;
    } ? INP : Record<string, unknown>): Iterable<NodeOutput>;
    /**
     * Resets the workflow by clearing the prompt and setting the workflow to undefined.
     */
    reset(): void;
    /**
     * Returns the current workflow object.
     *
     * @return {IWorkflow} The current workflow object.
     *
     * @deprecated use `workflow` instead
     */
    end(): IWorkflow;
    /**
     * Returns the current workflow object.
     *
     * @return {IWorkflow} The current workflow object.
     */
    workflow(): IWorkflow;
    /**
     * Guard function to check if the client's WebSocket is connected before attempting to invoke the workflow.
     *
     * @throws {Error} If the WebSocket is not connected.
     *
     * @param {Client} client - The client to check.
     *
     * @private
     */
    protected _ws_connected_guard(client: Client): void;
    /**
     * Invokes the workflow with the provided client and options.
     *
     * @param {Client} client - The client to use for the invocation.
     * @param {InvokeOptions<T>} [options] - Optional invoke options.
     * @return {Promise<WorkflowOutput<T>>} A promise resolving to the workflow output.
     */
    invoke<T>(client: Client, options?: InvokeOptions<T>): Promise<WorkflowOutput<T>>;
    invoke(client: Client, options?: InvokeOptions<unknown>): Promise<WorkflowOutput<unknown>>;
    /**
     * Creates a new invoked workflow instance.
     *
     * @param {Client} client - The client used to run the prompt.
     * @param {InvokeOptions<T>} [options] - Optional invoke options.
     * @return {InvokedWorkflow<T>} The invoked workflow instance.
     */
    instance<T>(client: Client, options?: InvokeOptions<T>): InvokedWorkflow<T>;
    instance(client: Client, options?: InvokeOptions<unknown>): InvokedWorkflow;
    /**
     * Invokes a workflow using the provided client with polling.
     *
     * @param {Client} client - The client used to run the prompt.
     * @param {InvokeOptions<T>} [options] - The options for invoking the workflow.
     * @return {Promise<WorkflowOutput<T>>} A promise that resolves with the result of the prompt.
     */
    invoke_polling<T>(client: Client, options?: InvokeOptions<T>): Promise<WorkflowOutput<T>>;
    invoke_polling(client: Client, options?: InvokeOptions<unknown>): Promise<WorkflowOutput>;
}

/**
 * Provide api-auth support for this https://github.com/liusida/ComfyUI-Login/tree/main extension
 */
declare class LoginAuthPlugin extends Plugin {
    readonly options: {
        token: string;
    };
    constructor(options: {
        token: string;
    });
}

type index_LoginAuthPlugin = LoginAuthPlugin;
declare const index_LoginAuthPlugin: typeof LoginAuthPlugin;
declare namespace index {
  export {
    index_LoginAuthPlugin as LoginAuthPlugin,
  };
}

declare const RESOLVERS: {
    image: WorkflowOutputResolver<WorkflowOutput>;
};

declare const builtins_RESOLVERS: typeof RESOLVERS;
declare namespace builtins {
  export {
    builtins_RESOLVERS as RESOLVERS,
  };
}

declare namespace NSPipeline {
    const samplers: readonly ["euler", "euler_cfg_pp", "euler_ancestral", "euler_ancestral_cfg_pp", "heun", "heunpp2", "exp_heun_2_x0", "exp_heun_2_x0_sde", "dpm_2", "dpm_2_ancestral", "lms", "dpm_fast", "dpm_adaptive", "dpmpp_2s_ancestral", "dpmpp_2s_ancestral_cfg_pp", "dpmpp_sde", "dpmpp_sde_gpu", "dpmpp_2m", "dpmpp_2m_cfg_pp", "dpmpp_2m_sde", "dpmpp_2m_sde_gpu", "dpmpp_2m_sde_heun", "dpmpp_2m_sde_heun_gpu", "dpmpp_3m_sde", "dpmpp_3m_sde_gpu", "ddpm", "lcm", "ipndm", "ipndm_v", "deis", "res_multistep", "res_multistep_cfg_pp", "res_multistep_ancestral", "res_multistep_ancestral_cfg_pp", "gradient_estimation", "gradient_estimation_cfg_pp", "er_sde", "seeds_2", "seeds_3", "sa_solver", "sa_solver_pece", "ddim", "uni_pc", "uni_pc_bh2"];
    const schedulers: readonly ["simple", "sgm_uniform", "karras", "exponential", "ddim_uniform", "beta", "normal", "linear_quadratic", "kl_optimal"];
    type PipeContext = {
        seed: number;
        steps: number;
        cfg: number;
        sampler_name: (typeof samplers)[number] | ({} & string);
        scheduler: (typeof schedulers)[number] | ({} & string);
        denoise: number;
        width: number;
        height: number;
        batch_size: number;
        ckpt_name: string;
        positive: string;
        negative: string;
        /**
         * NOTE: dependence custom node: `ETN_LoadImageBase64` and `ETN_LoadMaskBase64`
         */
        input_image: Buffer | null;
        input_mask: Buffer | null;
        grow_mask_by: number;
        client: Client | null;
    };
}

type PipeContext = NSPipeline.PipeContext;
/**
 * pipe to create a workflow
 */
declare class BasePipe<CTX extends PipeContext = PipeContext> extends Disposable {
    /**
     * Generates a random seed value.
     *
     * @return {number} A random integer seed value between 0 and MAX_SAFE_INTEGER.
     */
    static nextSeed(): number;
    static defaultContext: PipeContext;
    protected context: CTX;
    protected _workflow: Workflow;
    protected _invoked?: Promise<InvokedWorkflow>;
    constructor(context?: Partial<CTX>);
    protected update(ctx: Record<string, any>): void;
    /**
     * Updates the context with the provided image buffer.
     *
     * @param {Buffer} image - The image buffer to update the context with.
     * @return {this} The current instance of the class for method chaining.
     */
    image(image: Buffer): this;
    /**
     * Updates the context with the provided mask buffer.
     *
     * @param {Buffer} image - The mask buffer to update the context with.
     * @return {this} The current instance of the class for method chaining.
     */
    mask(image: Buffer): this;
    /**
     * Updates the context with the provided model checkpoint name.
     *
     * @param {string} ckpt_name - The name of the model checkpoint to update the context with.
     * @return {this} The current instance of the class for method chaining.
     */
    model(ckpt_name: string): this;
    /**
     * Updates the context with the provided width and height, and returns the current instance of the class for method chaining.
     *
     * @param {number} w - The width to update the context with.
     * @param {number} h - The height to update the context with.
     * @return {this} The current instance of the class for method chaining.
     */
    size(w: number, h: number): this;
    /**
     * Updates the context with the provided text as the positive prompt.
     *
     * @param {string} text - The text to update the context with.
     * @return {this} The current instance of the class for method chaining.
     */
    prompt(text: string): this;
    /**
     * Updates the context with the provided text as the negative prompt.
     *
     * @param {string} text - The text to update the context with.
     * @return {this} The current instance of the class for method chaining.
     */
    negative(text: string): this;
    /**
     * Updates the context with the provided steps and returns the current instance of the class for method chaining.
     *
     * @param {number} steps - The number of steps to update the context with.
     * @return {this} The current instance of the class for method chaining.
     */
    steps(steps: number): this;
    /**
     * Updates the context with the provided cfg value.
     *
     * @param {number} cfg - The cfg value to update the context with.
     * @return {this} The current instance of the class for method chaining.
     */
    cfg(cfg: number): this;
    /**
     * Updates the context with the provided seed value or generates a random seed value if none is provided.
     *
     * @param {number} [seed=BasePipe.nextSeed()] - The seed value to update the context with. If not provided, a random seed value will be generated.
     * @return {this} The current instance of the class for method chaining.
     */
    seed(seed?: number): this;
    /**
     * Updates the context with the provided denoise value and returns the current instance of the class for method chaining.
     *
     * @param {number} denoise - The denoise value to update the context with.
     * @return {this} The current instance of the class for method chaining.
     */
    denoise(denoise: number): this;
    /**
     * Updates the context with the provided scheduler value and returns the current instance of the class for method chaining.
     *
     * @param {PipeContext["scheduler"]} scheduler - The scheduler value to update the context with.
     * @return {this} The current instance of the class for method chaining.
     */
    scheduler(scheduler: PipeContext["scheduler"]): this;
    /**
     * Updates the context with the provided sampler name and returns the current instance of the class for method chaining.
     *
     * @param {PipeContext["sampler_name"]} sampler_name - The sampler name to update the context with.
     * @return {this} The current instance of the class for method chaining.
     */
    sampler(sampler_name: PipeContext["sampler_name"]): this;
    /**
     * Updates the context with the provided batch size and returns the current instance of the class for method chaining.
     *
     * @param {number} batch_size - The batch size to update the context with.
     * @return {this} The current instance of the class for method chaining.
     */
    batch_size(batch_size: number): this;
    /**
     * Updates the context with the provided client and returns the current instance of the class for method chaining.
     *
     * @param {Client} client - The client to update the context with.
     * @return {this} The current instance of the class for method chaining.
     */
    with(client: Client): this;
    /**
     * Adds an event listener for the specified event type.
     */
    on<T extends EventEmitter.EventNames<ComfyUIClientEvents>>(type: T, callback: EventEmitter.EventListener<ComfyUIClientEvents, T>, options?: any): this;
    /**
     * Adds an once event listener for the specified event type.
     */
    once<T extends EventEmitter.EventNames<ComfyUIClientEvents>>(type: T, callback: EventEmitter.EventListener<ComfyUIClientEvents, T>, options?: any): this;
    protected build_latent(vae: any): NodeOutput;
    protected build(): {
        samples: NodeOutput;
        vae: NodeOutput;
        cls: BuiltinNodeClasses & Record<string, ComfyUINodeClass<NodeClassInputs>>;
    };
    protected _save(filename_prefix?: string): void;
    protected read_response(res: WorkflowOutput<unknown>): Promise<{
        data: ArrayBuffer;
        mime: string;
    }[]>;
    /**
     * Saves the workflow by invoking the workflow instance and enqueuing it.
     *
     * @param {string} [filename_prefix] - The prefix for the saved filename. if not provided, the workflow will be saved as a websocket connection.
     * @return {this} - Returns the instance of the class for method chaining.
     * @throws {Error} - Throws an error if the client is not defined.
     */
    save(filename_prefix?: string): this;
    /**
     * Waits for the workflow to complete and returns the result and the images.
     *
     * @return {Promise<{result: WorkflowOutput<unknown>, images: {data: ArrayBuffer, mime: string}[]}>} - A promise that resolves to an object containing the result of the workflow and the images.
     * @throws {Error} - Throws an error if the workflow has not been invoked.
     */
    wait(): Promise<{
        result: WorkflowOutput;
        images: {
            data: ArrayBuffer;
            mime: string;
        }[];
    }>;
    /**
     * Waits for the workflow to complete and returns the result and the images.
     *
     * *This function does not rely on WebSocket Events, so it maybe will lose events output by WebSocket node
     *
     * @return {Promise<{result: WorkflowOutput<unknown>, images: {data: ArrayBuffer, mime: string}[]}>} - A promise that resolves to an object containing the result of the workflow and the images.
     * @throws {Error} - Throws an error if the workflow has not been invoked.
     */
    wait_polling(): Promise<{
        result: WorkflowOutput;
        images: {
            data: ArrayBuffer;
            mime: string;
        }[];
    }>;
}

interface EfficientPipeContext extends NSPipeline.PipeContext {
    vae_name: string;
    clip_skip: number;
    token_normalization: "none" | "mean" | "length" | "length+mean";
    weight_interpretation: "comfy" | "A1111" | "compel" | "comfy++" | "down_weight";
    loras: {
        name: string;
        weight: number;
        model_strength: number;
        clip_strength: number;
    }[];
    control_net_blocks: {
        image: Buffer;
        name: string;
        strength: number;
        start: number;
        end: number;
    }[];
}
/**
 * pipe to create a workflow
 *
 * required https://github.com/jags111/efficiency-nodes-comfyui
 */
declare class EfficientPipe extends BasePipe<EfficientPipeContext> {
    static defaultContext: EfficientPipeContext;
    constructor(context?: Partial<EfficientPipeContext>);
    /**
     * Adds a LoRA (Low-Rank Adaptation) to the EfficientPipe context.
     *
     * @param {string} name - The name of the LoRA.
     * @param {object} options - Optional configuration for the LoRA.
     * @param {number} [options.weight=1] - The weight of the LoRA.
     * @param {number} [options.strength=1] - The strength of the LoRA.
     * @param {number} [options.clip_strength=1] - The clip strength of the LoRA.
     * @return {EfficientPipe} The EfficientPipe instance for chaining.
     */
    lora(name: string, { weight, strength, clip_strength, }?: {
        weight?: number;
        strength?: number;
        clip_strength?: number;
    }): this;
    /**
     * Adds a control net block to the EfficientPipe context.
     *
     * @param {string} name - The name of the control net block.
     * @param {Buffer} image - The image data of the control net block.
     * @param {object} options - Optional configuration for the control net block.
     * @param {number} [options.strength=1] - The strength of the control net block.
     * @param {number} [options.start=0] - The start value of the control net block.
     * @param {number} [options.end=1] - The end value of the control net block.
     * @return {EfficientPipe} The EfficientPipe instance for chaining.
     */
    cnet(name: string, image: Buffer, { strength, start, end, }?: {
        strength?: number;
        start?: number;
        end?: number;
    }): this;
    protected build_lora_stack(): NodeOutput | undefined;
    protected build_cnet_block({ image, name, strength, start, end, }: EfficientPipeContext["control_net_blocks"][number], stack: any): NodeOutput;
    protected build_cnet_stack(): any;
    protected build(): {
        samples: NodeOutput;
        vae: NodeOutput;
        cls: BuiltinNodeClasses & Record<string, ComfyUINodeClass<NodeClassInputs>>;
    };
}

declare const outToB64Urls: (result: WorkflowOutput, { fetch, }?: {
    fetch?: typeof globalThis.fetch;
}) => Promise<string[]>;

declare class ClientError extends Error {
    constructor(message: string);
}
declare class PromptTimeoutError extends ClientError {
    constructor(prompt_id: string, timeout_ms: number);
}
declare class PromptEnqueueError extends ClientError {
    constructor(resp: ComfyUIClientResponseTypes.QueuePromptError);
}
declare class ClientEnqueueError extends ClientError {
    constructor(err_msg: string);
}
declare class PromptNotFoundError extends ClientError {
    constructor(prompt_id: string);
}
declare class TaskDataTypeError extends ClientError {
    constructor(task_data: any);
}
declare class PromptExecutionFailedError extends ClientError {
    constructor(prompt_id: string, status: string);
}
declare class ClientRequestError extends ClientError {
    constructor(err_msg: string);
}
declare class PollingTimeoutError extends ClientError {
    constructor(timeout_ms: number);
}
declare class WebSocketTimeoutError extends ClientError {
    constructor(timeout_ms: number);
}
declare class ConnectError extends ClientError {
    constructor(err_msg: string);
}
declare class WebSocketParseError extends ClientError {
    constructor(err_msg: string);
}
declare class HttpError extends Error {
    status: number;
    json: any;
    constructor(message: string, status: number, json?: any);
}

declare class WorkflowError extends Error {
    readonly task_id: string;
    readonly workflow?: IWorkflow | undefined;
    readonly invoked?: InvokedWorkflow | undefined;
    constructor(message: string, task_id: string, workflow?: IWorkflow | undefined, invoked?: InvokedWorkflow | undefined);
}
declare class WorkflowExecutionError extends WorkflowError {
    readonly payload: ComfyUiWsTypes.Messages.ExecutionError;
    constructor(payload: ComfyUiWsTypes.Messages.ExecutionError, task_id: string, workflow?: IWorkflow, invoked?: InvokedWorkflow<any>);
}
declare class ClientConnectionError extends Error {
    constructor(type: string, message: string);
}
declare class WorkflowGuardError extends Error {
    readonly invoked: InvokedWorkflow<any>;
    readonly workflow: IWorkflow;
    constructor(message: string, invoked: InvokedWorkflow<any>);
}
declare class WorkflowEnqueuedError extends WorkflowGuardError {
    constructor(invoked: InvokedWorkflow<any>);
}
declare class WorkflowTaskIdError extends WorkflowGuardError {
    constructor(invoked: InvokedWorkflow<any>);
}
declare class WorkflowDoneError extends WorkflowGuardError {
    constructor(invoked: InvokedWorkflow<any>);
}
declare class WorkflowWsError extends WorkflowGuardError {
    constructor(invoked: InvokedWorkflow<any>);
}
declare class WorkflowTaskStatusError extends WorkflowGuardError {
    constructor(invoked: InvokedWorkflow<any>);
}
declare class WorkflowInterruptedError extends WorkflowGuardError {
    constructor(invoked: InvokedWorkflow<any>);
}
declare class WorkflowArgumentError extends WorkflowGuardError {
    constructor(invoked: InvokedWorkflow<any>, message: string);
}

/**
 * @deprecated use `Client` instead
 */
declare const ComfyUIApiClient: typeof Client;
/**
 * @deprecated use `WsClient` instead
 */
declare const ComfyUIWsClient: typeof WsClient;
/**
 * @deprecated use `Workflow` instead
 */
declare const ComfyUIWorkflow: typeof Workflow;
/**
 * @deprecated use `Plugin` instead
 */
declare const ClientPlugin: typeof Plugin;

export { BasePipe, Client, ClientConnectionError, ClientEnqueueError, ClientError, ClientPlugin, ClientRequestError, ComfyUIApiClient, ComfyUIClientResponseTypes, ComfyUIWorkflow, ComfyUIWsClient, ComfyUiWsTypes, ConnectError, EfficientPipe, HttpError, NSPipeline, Plugin, PollingTimeoutError, PromptEnqueueError, PromptExecutionFailedError, PromptNotFoundError, PromptTimeoutError, TaskDataTypeError, WebSocketParseError, WebSocketTimeoutError, Workflow, WorkflowArgumentError, WorkflowDoneError, WorkflowEnqueuedError, WorkflowError, WorkflowExecutionError, WorkflowGuardError, WorkflowInterruptedError, WorkflowTaskIdError, WorkflowTaskStatusError, WorkflowWsError, WsClient, builtins, outToB64Urls, index as plugins };
export type { BuiltinNodeClasses, ComfyUIClientEvents, ComfyUINodeClass, EnqueueOptions, IComfyApiConfig, IWorkflow, InvokeOptions, LogEntry, LogsRawResponse, ModelFile, ModelFolderInfo, NodeClassInputs, NodeOutput, PromptBody, PromptMessage, PromptQueueHistory, PromptQueueItem, TerminalSize, WorkflowOutput, WorkflowOutputResolver, WorkflowPromptNode };