//!`advanced` definitions/categories.
#![allow(
    unused_imports,
    clippy::too_many_arguments,
    clippy::new_without_default,
    clippy::doc_lazy_continuation
)]
use std::collections::HashMap;
use crate::{
    workflow::{WorkflowNodeId, WorkflowInput},
    nodes::types::Out,
};
#[rustfmt::skip]
pub mod operations;
///**LatentAdd**: No description.
#[derive(Clone)]
#[allow(non_camel_case_types)]
pub struct LatentAdd<
    Samples1Param: crate::nodes::types::Latent,
    Samples2Param: crate::nodes::types::Latent,
> {
    ///No documentation.
    pub samples_1: Samples1Param,
    ///No documentation.
    pub samples_2: Samples2Param,
}
impl<
    Samples1Param: crate::nodes::types::Latent,
    Samples2Param: crate::nodes::types::Latent,
> LatentAdd<Samples1Param, Samples2Param> {
    /// Create a new node.
    pub fn new(samples_1: Samples1Param, samples_2: Samples2Param) -> Self {
        Self { samples_1, samples_2 }
    }
}
impl<
    Samples1Param: crate::nodes::types::Latent,
    Samples2Param: crate::nodes::types::Latent,
> crate::nodes::TypedNode for LatentAdd<Samples1Param, Samples2Param> {
    type Output = crate::nodes::types::LatentOut;
    fn output(&self, node_id: WorkflowNodeId) -> Self::Output {
        Self::Output::from_dynamic(node_id, 0)
    }
    fn inputs(&self) -> HashMap<String, WorkflowInput> {
        let mut output = HashMap::default();
        output.insert("samples1".to_string(), self.samples_1.clone().into());
        output.insert("samples2".to_string(), self.samples_2.clone().into());
        output
    }
    const NAME: &'static str = "LatentAdd";
    const DISPLAY_NAME: &'static str = "LatentAdd";
    const DESCRIPTION: &'static str = "";
    const CATEGORY: &'static str = "model/latent/advanced";
}
///**LatentBatchSeedBehavior**: No description.
#[derive(Clone)]
#[allow(non_camel_case_types)]
pub struct LatentBatchSeedBehavior<SamplesParam: crate::nodes::types::Latent> {
    ///No documentation.
    pub samples: SamplesParam,
}
impl<SamplesParam: crate::nodes::types::Latent> LatentBatchSeedBehavior<SamplesParam> {
    /// Create a new node.
    pub fn new(samples: SamplesParam) -> Self {
        Self { samples }
    }
}
impl<SamplesParam: crate::nodes::types::Latent> crate::nodes::TypedNode
for LatentBatchSeedBehavior<SamplesParam> {
    type Output = crate::nodes::types::LatentOut;
    fn output(&self, node_id: WorkflowNodeId) -> Self::Output {
        Self::Output::from_dynamic(node_id, 0)
    }
    fn inputs(&self) -> HashMap<String, WorkflowInput> {
        let mut output = HashMap::default();
        output.insert("samples".to_string(), self.samples.clone().into());
        output
    }
    const NAME: &'static str = "LatentBatchSeedBehavior";
    const DISPLAY_NAME: &'static str = "LatentBatchSeedBehavior";
    const DESCRIPTION: &'static str = "";
    const CATEGORY: &'static str = "model/latent/advanced";
}
///**LatentConcat**: No description.
#[derive(Clone)]
#[allow(non_camel_case_types)]
pub struct LatentConcat<
    Samples1Param: crate::nodes::types::Latent,
    Samples2Param: crate::nodes::types::Latent,
> {
    ///No documentation.
    pub samples_1: Samples1Param,
    ///No documentation.
    pub samples_2: Samples2Param,
}
impl<
    Samples1Param: crate::nodes::types::Latent,
    Samples2Param: crate::nodes::types::Latent,
> LatentConcat<Samples1Param, Samples2Param> {
    /// Create a new node.
    pub fn new(samples_1: Samples1Param, samples_2: Samples2Param) -> Self {
        Self { samples_1, samples_2 }
    }
}
impl<
    Samples1Param: crate::nodes::types::Latent,
    Samples2Param: crate::nodes::types::Latent,
> crate::nodes::TypedNode for LatentConcat<Samples1Param, Samples2Param> {
    type Output = crate::nodes::types::LatentOut;
    fn output(&self, node_id: WorkflowNodeId) -> Self::Output {
        Self::Output::from_dynamic(node_id, 0)
    }
    fn inputs(&self) -> HashMap<String, WorkflowInput> {
        let mut output = HashMap::default();
        output.insert("samples1".to_string(), self.samples_1.clone().into());
        output.insert("samples2".to_string(), self.samples_2.clone().into());
        output
    }
    const NAME: &'static str = "LatentConcat";
    const DISPLAY_NAME: &'static str = "LatentConcat";
    const DESCRIPTION: &'static str = "";
    const CATEGORY: &'static str = "model/latent/advanced";
}
///**LatentCut**: No description.
#[derive(Clone)]
#[allow(non_camel_case_types)]
pub struct LatentCut<
    SamplesParam: crate::nodes::types::Latent,
    IndexParam: crate::nodes::types::Int,
    AmountParam: crate::nodes::types::Int,
> {
    ///No documentation.
    pub samples: SamplesParam,
    /**No documentation.

**Metadata**:
  - Default: 0
  - Max: 16384
  - Min: -16384
  - Step: 1
*/
    pub index: IndexParam,
    /**No documentation.

**Metadata**:
  - Default: 1
  - Max: 16384
  - Min: 1
  - Step: 1
*/
    pub amount: AmountParam,
}
impl<
    SamplesParam: crate::nodes::types::Latent,
    IndexParam: crate::nodes::types::Int,
    AmountParam: crate::nodes::types::Int,
> LatentCut<SamplesParam, IndexParam, AmountParam> {
    /// Create a new node.
    pub fn new(samples: SamplesParam, index: IndexParam, amount: AmountParam) -> Self {
        Self { samples, index, amount }
    }
}
impl<
    SamplesParam: crate::nodes::types::Latent,
    IndexParam: crate::nodes::types::Int,
    AmountParam: crate::nodes::types::Int,
> crate::nodes::TypedNode for LatentCut<SamplesParam, IndexParam, AmountParam> {
    type Output = crate::nodes::types::LatentOut;
    fn output(&self, node_id: WorkflowNodeId) -> Self::Output {
        Self::Output::from_dynamic(node_id, 0)
    }
    fn inputs(&self) -> HashMap<String, WorkflowInput> {
        let mut output = HashMap::default();
        output.insert("samples".to_string(), self.samples.clone().into());
        output.insert("index".to_string(), self.index.clone().into());
        output.insert("amount".to_string(), self.amount.clone().into());
        output
    }
    const NAME: &'static str = "LatentCut";
    const DISPLAY_NAME: &'static str = "LatentCut";
    const DESCRIPTION: &'static str = "";
    const CATEGORY: &'static str = "model/latent/advanced";
}
///**LatentCutToBatch**: No description.
#[derive(Clone)]
#[allow(non_camel_case_types)]
pub struct LatentCutToBatch<
    SamplesParam: crate::nodes::types::Latent,
    SliceSizeParam: crate::nodes::types::Int,
> {
    ///No documentation.
    pub samples: SamplesParam,
    /**No documentation.

**Metadata**:
  - Default: 1
  - Max: 16384
  - Min: 1
  - Step: 1
*/
    pub slice_size: SliceSizeParam,
}
impl<
    SamplesParam: crate::nodes::types::Latent,
    SliceSizeParam: crate::nodes::types::Int,
> LatentCutToBatch<SamplesParam, SliceSizeParam> {
    /// Create a new node.
    pub fn new(samples: SamplesParam, slice_size: SliceSizeParam) -> Self {
        Self { samples, slice_size }
    }
}
impl<
    SamplesParam: crate::nodes::types::Latent,
    SliceSizeParam: crate::nodes::types::Int,
> crate::nodes::TypedNode for LatentCutToBatch<SamplesParam, SliceSizeParam> {
    type Output = crate::nodes::types::LatentOut;
    fn output(&self, node_id: WorkflowNodeId) -> Self::Output {
        Self::Output::from_dynamic(node_id, 0)
    }
    fn inputs(&self) -> HashMap<String, WorkflowInput> {
        let mut output = HashMap::default();
        output.insert("samples".to_string(), self.samples.clone().into());
        output.insert("slice_size".to_string(), self.slice_size.clone().into());
        output
    }
    const NAME: &'static str = "LatentCutToBatch";
    const DISPLAY_NAME: &'static str = "LatentCutToBatch";
    const DESCRIPTION: &'static str = "";
    const CATEGORY: &'static str = "model/latent/advanced";
}
///**LatentInterpolate**: No description.
#[derive(Clone)]
#[allow(non_camel_case_types)]
pub struct LatentInterpolate<
    Samples1Param: crate::nodes::types::Latent,
    Samples2Param: crate::nodes::types::Latent,
    RatioParam: crate::nodes::types::Float,
> {
    ///No documentation.
    pub samples_1: Samples1Param,
    ///No documentation.
    pub samples_2: Samples2Param,
    /**No documentation.

**Metadata**:
  - Default: 1
  - Max: 1
  - Min: 0
  - Step: 0.01
*/
    pub ratio: RatioParam,
}
impl<
    Samples1Param: crate::nodes::types::Latent,
    Samples2Param: crate::nodes::types::Latent,
    RatioParam: crate::nodes::types::Float,
> LatentInterpolate<Samples1Param, Samples2Param, RatioParam> {
    /// Create a new node.
    pub fn new(
        samples_1: Samples1Param,
        samples_2: Samples2Param,
        ratio: RatioParam,
    ) -> Self {
        Self {
            samples_1,
            samples_2,
            ratio,
        }
    }
}
impl<
    Samples1Param: crate::nodes::types::Latent,
    Samples2Param: crate::nodes::types::Latent,
    RatioParam: crate::nodes::types::Float,
> crate::nodes::TypedNode
for LatentInterpolate<Samples1Param, Samples2Param, RatioParam> {
    type Output = crate::nodes::types::LatentOut;
    fn output(&self, node_id: WorkflowNodeId) -> Self::Output {
        Self::Output::from_dynamic(node_id, 0)
    }
    fn inputs(&self) -> HashMap<String, WorkflowInput> {
        let mut output = HashMap::default();
        output.insert("samples1".to_string(), self.samples_1.clone().into());
        output.insert("samples2".to_string(), self.samples_2.clone().into());
        output.insert("ratio".to_string(), self.ratio.clone().into());
        output
    }
    const NAME: &'static str = "LatentInterpolate";
    const DISPLAY_NAME: &'static str = "LatentInterpolate";
    const DESCRIPTION: &'static str = "";
    const CATEGORY: &'static str = "model/latent/advanced";
}
///**LatentMultiply**: No description.
#[derive(Clone)]
#[allow(non_camel_case_types)]
pub struct LatentMultiply<
    SamplesParam: crate::nodes::types::Latent,
    MultiplierParam: crate::nodes::types::Float,
> {
    ///No documentation.
    pub samples: SamplesParam,
    /**No documentation.

**Metadata**:
  - Default: 1
  - Max: 10
  - Min: -10
  - Step: 0.01
*/
    pub multiplier: MultiplierParam,
}
impl<
    SamplesParam: crate::nodes::types::Latent,
    MultiplierParam: crate::nodes::types::Float,
> LatentMultiply<SamplesParam, MultiplierParam> {
    /// Create a new node.
    pub fn new(samples: SamplesParam, multiplier: MultiplierParam) -> Self {
        Self { samples, multiplier }
    }
}
impl<
    SamplesParam: crate::nodes::types::Latent,
    MultiplierParam: crate::nodes::types::Float,
> crate::nodes::TypedNode for LatentMultiply<SamplesParam, MultiplierParam> {
    type Output = crate::nodes::types::LatentOut;
    fn output(&self, node_id: WorkflowNodeId) -> Self::Output {
        Self::Output::from_dynamic(node_id, 0)
    }
    fn inputs(&self) -> HashMap<String, WorkflowInput> {
        let mut output = HashMap::default();
        output.insert("samples".to_string(), self.samples.clone().into());
        output.insert("multiplier".to_string(), self.multiplier.clone().into());
        output
    }
    const NAME: &'static str = "LatentMultiply";
    const DISPLAY_NAME: &'static str = "LatentMultiply";
    const DESCRIPTION: &'static str = "";
    const CATEGORY: &'static str = "model/latent/advanced";
}
///**LatentSubtract**: No description.
#[derive(Clone)]
#[allow(non_camel_case_types)]
pub struct LatentSubtract<
    Samples1Param: crate::nodes::types::Latent,
    Samples2Param: crate::nodes::types::Latent,
> {
    ///No documentation.
    pub samples_1: Samples1Param,
    ///No documentation.
    pub samples_2: Samples2Param,
}
impl<
    Samples1Param: crate::nodes::types::Latent,
    Samples2Param: crate::nodes::types::Latent,
> LatentSubtract<Samples1Param, Samples2Param> {
    /// Create a new node.
    pub fn new(samples_1: Samples1Param, samples_2: Samples2Param) -> Self {
        Self { samples_1, samples_2 }
    }
}
impl<
    Samples1Param: crate::nodes::types::Latent,
    Samples2Param: crate::nodes::types::Latent,
> crate::nodes::TypedNode for LatentSubtract<Samples1Param, Samples2Param> {
    type Output = crate::nodes::types::LatentOut;
    fn output(&self, node_id: WorkflowNodeId) -> Self::Output {
        Self::Output::from_dynamic(node_id, 0)
    }
    fn inputs(&self) -> HashMap<String, WorkflowInput> {
        let mut output = HashMap::default();
        output.insert("samples1".to_string(), self.samples_1.clone().into());
        output.insert("samples2".to_string(), self.samples_2.clone().into());
        output
    }
    const NAME: &'static str = "LatentSubtract";
    const DISPLAY_NAME: &'static str = "LatentSubtract";
    const DESCRIPTION: &'static str = "";
    const CATEGORY: &'static str = "model/latent/advanced";
}
